import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, describe, expect, it } from 'vitest'
import {
  parseNamedExports,
  parseNamedExportSpecs,
  parseInlineNamedExports,
  resolveLocalExportPath,
  resolveNamedExportPath,
} from '../../../scripts/extract-docs-exports'

const tempDirs: string[] = []

function createTempDir(): string {
  const dir = mkdtempSync(join(tmpdir(), 'mint-docs-exports-'))
  tempDirs.push(dir)
  return dir
}

afterEach(() => {
  for (const dir of tempDirs.splice(0)) {
    rmSync(dir, { recursive: true, force: true })
  }
})

describe('extract docs export helpers', () => {
  it('parses aliased named export specs and skips invalid entries', () => {
    expect(parseNamedExportSpecs(`
      type LocalType as PublicType,
      InternalName as PublicName,
      default,
      invalid-name,
      // ignored
    `)).toEqual([
      { localName: 'LocalType', exportedName: 'PublicType' },
      { localName: 'InternalName', exportedName: 'PublicName' },
    ])
  })

  it('resolves local export paths across files and directory indexes', () => {
    const dir = createTempDir()
    const indexPath = join(dir, 'index.ts')
    const featureDir = join(dir, 'feature')
    writeFileSync(indexPath, '')
    writeFileSync(join(dir, 'direct.ts'), 'export const Direct = 1')
    writeFileSync(join(dir, 'component.vue'), '<template />')
    mkdirSync(featureDir)
    writeFileSync(join(featureDir, 'index.ts'), 'export const Nested = 1')

    expect(resolveLocalExportPath(indexPath, './direct')).toBe(join(dir, 'direct.ts'))
    expect(resolveLocalExportPath(indexPath, './component')).toBe(join(dir, 'component.vue'))
    expect(resolveLocalExportPath(indexPath, './feature')).toBe(join(featureDir, 'index.ts'))
    expect(resolveLocalExportPath(indexPath, 'vue')).toBeNull()
  })

  it('collects inline exported declarations', () => {
    expect(parseInlineNamedExports(`
      export interface Item {}
      export type ItemId = string
      export const makeItem = () => ({})
      export function parseItem() {}
      export class ItemStore {}
      export enum ItemKind { A = 'a' }
      export default function ignored() {}
    `)).toEqual(['Item', 'ItemId', 'ItemKind', 'ItemStore', 'makeItem', 'parseItem'])
  })

  it('collects and resolves named exports through re-export chains', () => {
    const dir = createTempDir()
    const indexPath = join(dir, 'index.ts')
    const nestedPath = join(dir, 'nested.ts')
    const leafPath = join(dir, 'leaf.ts')
    const starPath = join(dir, 'star.ts')
    writeFileSync(indexPath, `
      export { Leaf as PublicLeaf } from './nested'
      export * from './leaf'
    `)
    writeFileSync(nestedPath, "export { InternalLeaf as Leaf } from './leaf'")
    writeFileSync(leafPath, "export const InternalLeaf = 1\nexport { StarExport } from './star'")
    writeFileSync(starPath, 'export const StarExport = 2')

    expect(parseNamedExports(indexPath)).toEqual([
      { name: 'InternalLeaf' },
      { name: 'PublicLeaf' },
      { name: 'StarExport' },
    ])
    expect(resolveNamedExportPath(indexPath, 'InternalLeaf')).toBe(leafPath)
    expect(resolveNamedExportPath(indexPath, 'PublicLeaf')).toBe(leafPath)
    expect(resolveNamedExportPath(indexPath, 'StarExport')).toBe(starPath)
  })
})