import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import { mkdtemp, mkdir, writeFile, rm, symlink } from 'fs/promises'
import { tmpdir } from 'os'
import { join } from 'path'
import { scanFolders, semanticEquals, SEMANTIC_MAX_BYTES, type FolderEntry } from './folderScan'

/** 以临时目录为根构造两个待对比文件夹 */
let leftDir: string
let rightDir: string

beforeAll(async () => {
  const root = await mkdtemp(join(tmpdir(), 'difflens-scan-'))
  leftDir = join(root, 'left')
  rightDir = join(root, 'right')
  await mkdir(leftDir, { recursive: true })
  await mkdir(rightDir, { recursive: true })
})

afterAll(async () => {
  await rm(join(leftDir, '..'), { recursive: true, force: true })
})

async function put(dir: 'left' | 'right', rel: string, content: string | Buffer): Promise<void> {
  const path = join(dir === 'left' ? leftDir : rightDir, rel)
  const idx = rel.lastIndexOf('/')
  if (idx >= 0) await mkdir(join(path, '..'), { recursive: true })
  await writeFile(path, content)
}

const byRel = (entries: FolderEntry[], rel: string): FolderEntry | undefined =>
  entries.find((e) => e.rel === rel)

describe('scanFolders - 状态判定', () => {
  it('两侧内容一致判为 same，内容不同（同大小）判为 different，大小不同判为 different', async () => {
    await put('left', 'same.txt', 'hello')
    await put('right', 'same.txt', 'hello')
    await put('left', 'content-diff.txt', 'abc')
    await put('right', 'content-diff.txt', 'abd')
    await put('left', 'size-diff.txt', 'short')
    await put('right', 'size-diff.txt', 'much longer text')

    const r = await scanFolders(leftDir, rightDir)
    expect(r.truncated).toBe(false)
    expect(byRel(r.entries, 'same.txt')).toMatchObject({ status: 'same', leftSize: 5, rightSize: 5 })
    expect(byRel(r.entries, 'content-diff.txt')?.status).toBe('different')
    expect(byRel(r.entries, 'size-diff.txt')).toMatchObject({ status: 'different' })
  })

  it('单侧缺失判为 only，大小字段另一侧为 null', async () => {
    await put('left', 'only-left.txt', 'L')
    await put('right', 'only-right.txt', 'R')
    const r = await scanFolders(leftDir, rightDir)
    expect(byRel(r.entries, 'only-left.txt')).toMatchObject({
      status: 'left-only',
      leftSize: 1,
      rightSize: null
    })
    expect(byRel(r.entries, 'only-right.txt')).toMatchObject({
      status: 'right-only',
      leftSize: null,
      rightSize: 1
    })
  })

  it('递归子目录条目按相对路径对齐（统一 / 分隔）', async () => {
    await put('left', 'src/core/a.ts', 'export const a = 1\n')
    await put('right', 'src/core/a.ts', 'export const a = 2\n')
    await put('right', 'src/util/b.ts', 'export const b = 1\n')
    const r = await scanFolders(leftDir, rightDir)
    expect(byRel(r.entries, 'src/core/a.ts')?.status).toBe('different')
    expect(byRel(r.entries, 'src/util/b.ts')?.status).toBe('right-only')
  })

  it('二进制内容同样按字节判定（含 NUL 字节文件）', async () => {
    await put('left', 'bin.dat', Buffer.from([0x00, 0x01, 0x02, 0x03]))
    await put('right', 'bin.dat', Buffer.from([0x00, 0x01, 0x02, 0x04]))
    const r = await scanFolders(leftDir, rightDir)
    expect(byRel(r.entries, 'bin.dat')?.status).toBe('different')
  })

  it('symlink 被跳过（防环且不参与判定）', async () => {
    // 建一个指向已存在子目录的 symlink，不应出现在结果中也不应导致递归
    await symlink(join(leftDir, 'src'), join(leftDir, 'src-link'), 'dir').catch(() => {})
    const r = await scanFolders(leftDir, rightDir)
    expect(r.entries.some((e) => e.rel.startsWith('src-link/'))).toBe(false)
  })

  it('条目按相对路径字典序排序', async () => {
    const r = await scanFolders(leftDir, rightDir)
    const rels = r.entries.map((e) => e.rel)
    expect([...rels].sort()).toEqual(rels)
  })

  it('total 为两侧枚举文件数的较大值', async () => {
    const r = await scanFolders(leftDir, rightDir)
    const leftCount = r.entries.filter((e) => e.leftSize !== null).length
    const rightCount = r.entries.filter((e) => e.rightSize !== null).length
    expect(r.total).toBeGreaterThanOrEqual(Math.max(leftCount, rightCount))
  })
})

describe('scanFolders - 边界与选项', () => {
  it('两个空目录返回空结果', async () => {
    const emptyL = await mkdtemp(join(tmpdir(), 'difflens-empty-l-'))
    const emptyR = await mkdtemp(join(tmpdir(), 'difflens-empty-r-'))
    try {
      const r = await scanFolders(emptyL, emptyR)
      expect(r.entries).toEqual([])
      expect(r.total).toBe(0)
      expect(r.truncated).toBe(false)
    } finally {
      await rm(emptyL, { recursive: true, force: true })
      await rm(emptyR, { recursive: true, force: true })
    }
  })

  it('目录不存在时不再抛异常：该侧按无文件处理（另一侧条目为 only）', async () => {
    // 单目录 IO 失败降级（被锁/权限）而非整体失败：大目录下单点锁不丢弃全部结果
    const r = await scanFolders(join(leftDir, 'not-exist'), rightDir)
    expect(r.entries.length).toBeGreaterThan(0)
    expect(r.entries.every((e) => e.status === 'right-only')).toBe(true)
  })

  it('maxFiles 截断：条目不完整且 truncated 为 true', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-trunc-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-trunc-r-'))
    try {
      for (let i = 0; i < 5; i++) {
        await writeFile(join(l, `f${i}.txt`), String(i))
        await writeFile(join(r, `f${i}.txt`), String(i))
      }
      const res = await scanFolders(l, r, { maxFiles: 2 })
      expect(res.truncated).toBe(true)
      expect(res.total).toBe(5)
      expect(res.entries.length).toBeLessThanOrEqual(2)
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })

  it('截断后不再深入子目录（凑满即停，total 为已遍历下限）', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-stop-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-stop-r-'))
    try {
      // 根目录 3 个文件 + 子目录 1 个文件，maxFiles=2：凑满后子目录不被遍历
      // （readdir 目录内条目顺序不保证，但 3 个根文件计入 total 与顺序无关）
      for (let i = 0; i < 3; i++) {
        await writeFile(join(l, `f${i}.txt`), String(i))
        await writeFile(join(r, `f${i}.txt`), String(i))
      }
      await mkdir(join(l, 'sub'), { recursive: true })
      await mkdir(join(r, 'sub'), { recursive: true })
      await writeFile(join(l, 'sub', 'inner.txt'), 'x')
      await writeFile(join(r, 'sub', 'inner.txt'), 'x')
      const res = await scanFolders(l, r, { maxFiles: 2 })
      expect(res.truncated).toBe(true)
      // 根目录 3 文件全部计入（当前目录统计完整），sub 未被深入
      expect(res.total).toBe(3)
      expect(res.entries.some((e) => e.rel.startsWith('sub/'))).toBe(false)
      expect(res.entries.length).toBeLessThanOrEqual(2)
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })

  it('超过 maxContentBytes 的同大小文件：头部采样一致判 same 且带 approximate 标注', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-big-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-big-r-'))
    try {
      // 100KB 文件、maxContentBytes 压到 1KB：走采样路径；头部 8KB 一致 → same + approximate
      const head = Buffer.alloc(8 * 1024, 0x41)
      const tailL = Buffer.alloc(100 * 1024 - head.length, 0x01)
      const tailR = Buffer.alloc(100 * 1024 - head.length, 0x02)
      await writeFile(join(l, 'big.bin'), Buffer.concat([head, tailL]))
      await writeFile(join(r, 'big.bin'), Buffer.concat([head, tailR]))
      const res = await scanFolders(l, r, { maxContentBytes: 1024 })
      expect(byRel(res.entries, 'big.bin')).toMatchObject({ status: 'same', approximate: true })
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })

  it('采样头部不同直接判 different', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-head-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-head-r-'))
    try {
      await writeFile(join(l, 'big.bin'), Buffer.alloc(100 * 1024, 0x01))
      await writeFile(join(r, 'big.bin'), Buffer.alloc(100 * 1024, 0x02))
      const res = await scanFolders(l, r, { maxContentBytes: 1024 })
      expect(byRel(res.entries, 'big.bin')?.status).toBe('different')
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })
})

describe('scanFolders - 语义判等', () => {
  /** 语义判等注入：同步解码（UTF-8 直读）+ 文本扩展名白名单 */
  const SEMANTIC = {
    maxBytes: SEMANTIC_MAX_BYTES,
    isTextFile: (rel: string): boolean => {
      const ext = rel.slice(rel.lastIndexOf('.') + 1).toLowerCase()
      return ['txt', 'md', 'json', 'ts'].includes(ext)
    },
    decode: async (buf: Buffer): Promise<string> => buf.toString('utf-8')
  }

  it('semanticEquals：空白/换行/空行差异判等，跨行重排判等，实质差异与大小写不判等', () => {
    expect(semanticEquals('a b', 'ab')).toBe(true)
    expect(semanticEquals('a\r\nb', 'a\nb')).toBe(true)
    expect(semanticEquals('a\n\n\nb', 'ab')).toBe(true)
    expect(semanticEquals('ab cd', 'ab\ncd')).toBe(true)
    expect(semanticEquals('abc', 'abd')).toBe(false)
    expect(semanticEquals('ABC', 'abc')).toBe(false)
    expect(semanticEquals('', '')).toBe(true)
  })

  it('仅空白/换行差异的文本文件判为 semantic-same（同大小与不同大小均覆盖）', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-sem-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-sem-r-'))
    try {
      // 不同大小：行内空白差异（tab/空格/数量）
      await writeFile(join(l, 'ws.txt'), 'a\tb\nc d\n')
      await writeFile(join(r, 'ws.txt'), 'a b\nc  d\n')
      // 不同大小：CRLF vs LF
      await writeFile(join(l, 'crlf.txt'), 'line1\r\nline2\r\n')
      await writeFile(join(r, 'crlf.txt'), 'line1\nline2\n')
      // 排版重排（跨行重组）
      await writeFile(join(l, 'reflow.txt'), 'hello world\n')
      await writeFile(join(r, 'reflow.txt'), 'hello\nworld\n')
      const res = await scanFolders(l, r, { semantic: SEMANTIC })
      expect(byRel(res.entries, 'ws.txt')?.status).toBe('semantic-same')
      expect(byRel(res.entries, 'crlf.txt')?.status).toBe('semantic-same')
      expect(byRel(res.entries, 'reflow.txt')?.status).toBe('semantic-same')
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })

  it('实质内容差异与大小写差异仍判 different', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-sem2-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-sem2-r-'))
    try {
      await writeFile(join(l, 'real.txt'), 'value = 1\n')
      await writeFile(join(r, 'real.txt'), 'value = 2\n')
      await writeFile(join(l, 'case.txt'), 'Config\n')
      await writeFile(join(r, 'case.txt'), 'config\n')
      const res = await scanFolders(l, r, { semantic: SEMANTIC })
      expect(byRel(res.entries, 'real.txt')?.status).toBe('different')
      expect(byRel(res.entries, 'case.txt')?.status).toBe('different')
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })

  it('非文本扩展名与超大小上限的条目不参与语义判等（保持字节级 different）', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-sem3-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-sem3-r-'))
    try {
      // 非文本扩展名（.bin 不在白名单）：仅空白差异仍判 different
      await writeFile(join(l, 'data.bin'), 'a b\n')
      await writeFile(join(r, 'data.bin'), 'ab\n')
      // 大小超上限（注入 maxBytes=4）：仅空白差异仍判 different
      await writeFile(join(l, 'big.txt'), 'aaaa bbbb\n')
      await writeFile(join(r, 'big.txt'), 'aaaabbbb\n')
      const res = await scanFolders(l, r, {
        semantic: { ...SEMANTIC, maxBytes: 4 }
      })
      expect(byRel(res.entries, 'data.bin')?.status).toBe('different')
      expect(byRel(res.entries, 'big.txt')?.status).toBe('different')
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })

  it('未开启语义判等时空白差异保持字节级 different（行为与 0.6.2 一致）', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-sem4-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-sem4-r-'))
    try {
      await writeFile(join(l, 'ws.txt'), 'a b\n')
      await writeFile(join(r, 'ws.txt'), 'ab\n')
      const res = await scanFolders(l, r)
      expect(byRel(res.entries, 'ws.txt')?.status).toBe('different')
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })

  it('字节一致的文件不受语义开关影响（仍判 same，不触发解码）', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-sem5-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-sem5-r-'))
    let decoded = 0
    try {
      await writeFile(join(l, 'same.txt'), 'same content\n')
      await writeFile(join(r, 'same.txt'), 'same content\n')
      const res = await scanFolders(l, r, {
        semantic: { ...SEMANTIC, decode: async (b) => { decoded++; return b.toString('utf-8') } }
      })
      expect(byRel(res.entries, 'same.txt')?.status).toBe('same')
      expect(decoded).toBe(0)
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })

  it('单文件 IO 失败（模拟被锁）标记 unreadable，不影响其余条目判定', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-sem6-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-sem6-r-'))
    try {
      // 正常差异文件 + 失败文件（decode 抛异常模拟读取后置失败，如 Windows 文件锁）
      await writeFile(join(l, 'ok.txt'), 'a\n')
      await writeFile(join(r, 'ok.txt'), 'b\n')
      await writeFile(join(l, 'locked.txt'), 'x y\n')
      await writeFile(join(r, 'locked.txt'), 'xy\n')
      const res = await scanFolders(l, r, {
        semantic: {
          ...SEMANTIC,
          decode: async (b) => {
            if (b.toString('utf-8').includes('x')) throw new Error('EBUSY')
            return b.toString('utf-8')
          }
        }
      })
      expect(byRel(res.entries, 'ok.txt')?.status).toBe('different')
      expect(byRel(res.entries, 'locked.txt')?.status).toBe('unreadable')
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })
})

describe('scanFolders - 受控并发内容比对', () => {
  it('跨多个并发批次的混合状态全部判定正确且排序不变', async () => {
    const l = await mkdtemp(join(tmpdir(), 'difflens-conc-l-'))
    const r = await mkdtemp(join(tmpdir(), 'difflens-conc-r-'))
    try {
      // 40 个大小一致的条目 > 2×SCAN_CONCURRENCY(16)，覆盖至少 3 个并发批次；
      // 状态混排：偶数 same / 奇数 different / 尾部两个单侧
      const total = 40
      for (let i = 0; i < total; i++) {
        const same = i % 2 === 0
        const content = same ? `c${i}` : `L${i}`
        const contentR = same ? `c${i}` : `R${i}`
        await writeFile(join(l, `f${String(i).padStart(2, '0')}.txt`), content)
        await writeFile(join(r, `f${String(i).padStart(2, '0')}.txt`), contentR)
      }
      await writeFile(join(l, 'zz-only-left.txt'), 'L')
      await writeFile(join(r, 'zz-only-right.txt'), 'R')

      const res = await scanFolders(l, r)
      expect(res.entries).toHaveLength(total + 2)
      // 每个条目状态正确（并发写回槽位不丢不错）
      for (let i = 0; i < total; i++) {
        const rel = `f${String(i).padStart(2, '0')}.txt`
        expect(byRel(res.entries, rel)?.status).toBe(i % 2 === 0 ? 'same' : 'different')
      }
      expect(byRel(res.entries, 'zz-only-left.txt')?.status).toBe('left-only')
      expect(byRel(res.entries, 'zz-only-right.txt')?.status).toBe('right-only')
      // 排序仍为字典序（输出顺序与并发执行顺序无关）
      const rels = res.entries.map((e) => e.rel)
      expect([...rels].sort()).toEqual(rels)
    } finally {
      await rm(l, { recursive: true, force: true })
      await rm(r, { recursive: true, force: true })
    }
  })
})