import fs from 'fs'
import path from 'path'

function toPascalCase(str: string): string {
	return str
		.split(/[-_.]/)
		.filter((part) => part.length > 0)
		.map((word) => {
			if (/^\d/.test(word)) {
				return word.charAt(0).toUpperCase() + word.slice(1)
			}
			return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
		})
		.join('')
}

function generateIconExports(): { imports: string; exports: string } {
	const packageRoot = path.resolve(__dirname, '..')
	const iconsDir = path.join(packageRoot, 'icons')

	if (!fs.existsSync(iconsDir)) {
		throw new Error(`Icons directory not found: ${iconsDir}`)
	}

	const files = fs
		.readdirSync(iconsDir)
		.filter((file) => file.endsWith('.svg'))
		.sort()

	let imports = ''
	let exports = ''

	files.forEach((file) => {
		const baseName = path.basename(file, '.svg')
		let pascalName = toPascalCase(baseName)

		if (pascalName === '') {
			pascalName = 'Unknown'
		}

		if (!pascalName.endsWith('Icon')) {
			pascalName += 'Icon'
		}

		const privateName = `_${pascalName}`

		imports += `import ${privateName} from './icons/${file}?component'\n`
		exports += `export const ${pascalName} = ${privateName}\n`
	})

	return { imports, exports }
}

function runTests(): void {
	console.log('🧪 Running conversion tests...\n')

	const testCases: Array<{ input: string; expected: string }> = [
		{ input: 'align-left', expected: 'AlignLeftIcon' },
		{ input: 'arrow-big-up-dash', expected: 'ArrowBigUpDashIcon' },
		{ input: 'check-check', expected: 'CheckCheckIcon' },
		{ input: 'chevron-left', expected: 'ChevronLeftIcon' },
		{ input: 'file-archive', expected: 'FileArchiveIcon' },
		{ input: 'heart-handshake', expected: 'HeartHandshakeIcon' },
		{ input: 'monitor-smartphone', expected: 'MonitorSmartphoneIcon' },
		{ input: 'x-circle', expected: 'XCircleIcon' },
		{ input: 'rotate-ccw', expected: 'RotateCcwIcon' },
		{ input: 'bell-ring', expected: 'BellRingIcon' },
		{ input: 'more-horizontal', expected: 'MoreHorizontalIcon' },
		{ input: 'list_bulleted', expected: 'ListBulletedIcon' },
		{ input: 'test.name', expected: 'TestNameIcon' },
		{ input: 'test-name_final.icon', expected: 'TestNameFinalIcon' },
	]

	let passed = 0
	let failed = 0

	testCases.forEach(({ input, expected }) => {
		const result = toPascalCase(input) + (toPascalCase(input).endsWith('Icon') ? '' : 'Icon')
		const success = result === expected

		if (success) {
			console.log(`✅ ${input} → ${result}`)
			passed++
		} else {
			console.log(`❌ ${input} → ${result} (expected: ${expected})`)
			failed++
		}
	})

	console.log(`\n📊 Test Results: ${passed} passed, ${failed} failed`)

	if (failed > 0) {
		process.exit(1)
	}
}

function generateFiles(): void {
	try {
		console.log('🔄 Generating icon exports...')

		const { imports, exports } = generateIconExports()
		const output = `// Auto-generated icon imports and exports
// Do not edit this file manually - run 'pnpm run fix' to regenerate

${imports}
${exports}`

		const packageRoot = path.resolve(__dirname, '..')
		const outputPath = path.join(packageRoot, 'generated-icons.ts')
		fs.writeFileSync(outputPath, output)

		console.log(`✅ Generated icon exports to: ${outputPath}`)
		console.log(
			`📦 Generated ${imports.split('\n').filter((line) => line.trim()).length} icon imports/exports`,
		)
	} catch (error) {
		console.error('❌ Error generating icons:', error)
		process.exit(1)
	}
}

function main(): void {
	const args = process.argv.slice(2)

	if (args.includes('--test')) {
		runTests()
	} else if (args.includes('--validate')) {
		validateIconConsistency()
	} else {
		generateFiles()
	}
}

main()

function getExpectedIconExports(iconsDir: string): string[] {
	if (!fs.existsSync(iconsDir)) {
		return []
	}

	return fs
		.readdirSync(iconsDir)
		.filter((file) => file.endsWith('.svg'))
		.map((file) => {
			const baseName = path.basename(file, '.svg')
			let pascalName = toPascalCase(baseName)

			if (pascalName === '') {
				pascalName = 'Unknown'
			}

			if (!pascalName.endsWith('Icon')) {
				pascalName += 'Icon'
			}

			return pascalName
		})
		.sort()
}

function getActualIconExports(indexFile: string): string[] {
	if (!fs.existsSync(indexFile)) {
		return []
	}

	const content = fs.readFileSync(indexFile, 'utf8')
	const exportMatches = content.match(/export const (\w+Icon) = _\w+Icon/g) || []

	return exportMatches
		.map((match) => {
			const result = match.match(/export const (\w+Icon)/)
			return result ? result[1] : ''
		})
		.filter((name) => name.endsWith('Icon'))
		.sort()
}

function validateIconConsistency(): void {
	try {
		console.log('🔍 Validating icon consistency...')

		const packageRoot = path.resolve(__dirname, '..')
		const iconsDir = path.join(packageRoot, 'icons')
		const declarationFile = path.join(packageRoot, 'generated-icons.ts')

		const expectedExports = getExpectedIconExports(iconsDir)
		const actualExports = getActualIconExports(declarationFile)

		const missingExports = expectedExports.filter((name) => !actualExports.includes(name))
		const extraExports = actualExports.filter((name) => !expectedExports.includes(name))

		if (missingExports.length > 0) {
			console.error(`❌ Missing icon exports: ${missingExports.join(', ')}`)
			console.error("Run 'pnpm run fix' to generate them.")
			process.exit(1)
		}

		if (extraExports.length > 0) {
			console.error(
				`❌ Extra icon exports (no corresponding SVG files): ${extraExports.join(', ')}`,
			)
			console.error("Run 'pnpm run fix' to clean them up.")
			process.exit(1)
		}

		console.log('✅ Icon exports are consistent with SVG files')
	} catch (error) {
		console.error('❌ Error validating icons:', error)
		process.exit(1)
	}
}
