export type NodePackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun'
export type NodePackageManagerPreference = 'auto' | NodePackageManager

export interface ProjectFileSnapshot {
  name: string
  isDirectory?: boolean
  content?: string
}

export interface ProjectTask {
  id: string
  name: string
  command: string
  ecosystem: string
  source: string
}

export interface ProjectTaskDiscoveryOptions {
  nodePackageManager?: NodePackageManagerPreference
  platform?: 'win32' | 'darwin' | 'linux'
}

const SAFE_TASK_NAME = /^[\p{L}\p{N}_@./:-]+$/u

function parseJsonObject(content?: string): Record<string, unknown> | null {
  if (!content) return null
  try {
    const parsed = JSON.parse(content)
    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
      ? parsed as Record<string, unknown>
      : null
  } catch {
    return null
  }
}

function addTask(tasks: ProjectTask[], task: ProjectTask): void {
  if (!task.command.trim() || tasks.some(existing => existing.command === task.command)) return
  tasks.push(task)
}

function addStandardTasks(
  tasks: ProjectTask[],
  ecosystem: string,
  source: string,
  commands: Array<[name: string, command: string]>,
): void {
  for (const [name, command] of commands) {
    addTask(tasks, {
      id: `${ecosystem.toLowerCase()}:${name.toLowerCase()}:${command}`,
      name,
      command,
      ecosystem,
      source,
    })
  }
}

export function detectNodePackageManager(
  fileNames: Iterable<string>,
  packageJsonContent?: string,
  preference: NodePackageManagerPreference = 'auto',
): NodePackageManager {
  if (preference !== 'auto') return preference

  const packageJson = parseJsonObject(packageJsonContent)
  const declared = typeof packageJson?.packageManager === 'string'
    ? packageJson.packageManager.split('@')[0]
    : ''
  if (declared === 'npm' || declared === 'pnpm' || declared === 'yarn' || declared === 'bun') {
    return declared
  }

  const names = new Set(Array.from(fileNames, name => name.toLowerCase()))
  if (names.has('pnpm-lock.yaml')) return 'pnpm'
  if (names.has('yarn.lock')) return 'yarn'
  if (names.has('bun.lock') || names.has('bun.lockb')) return 'bun'
  return 'npm'
}

export function nodeScriptCommand(manager: NodePackageManager, scriptName: string): string | null {
  const name = scriptName.trim()
  if (!name || !SAFE_TASK_NAME.test(name)) return null
  return `${manager} run ${name}`
}

function extractTomlScriptNames(content: string): string[] {
  const supportedSections = new Set([
    'project.scripts',
    'tool.poetry.scripts',
    'tool.pdm.scripts',
  ])
  const names: string[] = []
  let section = ''

  for (const rawLine of content.split(/\r?\n/)) {
    const line = rawLine.trim()
    const sectionMatch = line.match(/^\[([^\]]+)]$/)
    if (sectionMatch) {
      section = sectionMatch[1].trim()
      continue
    }
    if (!supportedSections.has(section) || line.startsWith('#')) continue
    const keyMatch = line.match(/^([\p{L}\p{N}_@./:-]+)\s*=/u)
    if (keyMatch && SAFE_TASK_NAME.test(keyMatch[1])) names.push(keyMatch[1])
  }

  return names
}

function extractBuildTargets(content: string, syntax: 'make' | 'just'): string[] {
  const targets: string[] = []
  for (const rawLine of content.split(/\r?\n/)) {
    if (!rawLine || /^\s/.test(rawLine) || rawLine.startsWith('#')) continue
    const match = syntax === 'make'
      ? rawLine.match(/^([\p{L}\p{N}_./-]+)\s*:(?![=])/u)
      : rawLine.match(/^([\p{L}\p{N}_./-]+)(?:\s+[^:=]+)?\s*:/u)
    const target = match?.[1]
    if (!target || target.startsWith('.') || !SAFE_TASK_NAME.test(target)) continue
    if (!targets.includes(target)) targets.push(target)
  }
  return targets.slice(0, 20)
}

function pythonPrefix(manager: 'uv' | 'poetry' | 'pdm' | 'pipenv' | 'python'): string {
  if (manager === 'python') return ''
  return `${manager} run `
}

export function discoverProjectTasks(
  files: ProjectFileSnapshot[],
  options: ProjectTaskDiscoveryOptions = {},
): ProjectTask[] {
  const tasks: ProjectTask[] = []
  const byName = new Map(files.map(file => [file.name.toLowerCase(), file]))
  const has = (name: string) => byName.has(name.toLowerCase())
  const content = (name: string) => byName.get(name.toLowerCase())?.content || ''
  const platform = options.platform || 'linux'

  if (has('package.json')) {
    const packageJsonContent = content('package.json')
    const packageJson = parseJsonObject(packageJsonContent)
    const scripts = packageJson?.scripts
    const manager = detectNodePackageManager(byName.keys(), packageJsonContent, options.nodePackageManager)
    if (scripts && typeof scripts === 'object' && !Array.isArray(scripts)) {
      for (const name of Object.keys(scripts as Record<string, unknown>)) {
        const command = nodeScriptCommand(manager, name)
        if (!command) continue
        addTask(tasks, {
          id: `node:${name}`,
          name,
          command,
          ecosystem: `Node.js · ${manager}`,
          source: 'package.json',
        })
      }
    }
  }

  if (has('deno.json')) {
    const deno = parseJsonObject(content('deno.json'))
    const scripts = deno?.tasks
    if (scripts && typeof scripts === 'object' && !Array.isArray(scripts)) {
      for (const name of Object.keys(scripts as Record<string, unknown>)) {
        if (!SAFE_TASK_NAME.test(name)) continue
        addTask(tasks, { id: `deno:${name}`, name, command: `deno task ${name}`, ecosystem: 'Deno', source: 'deno.json' })
      }
    }
  }

  if (has('pyproject.toml') || has('requirements.txt') || has('pipfile')) {
    const pyproject = content('pyproject.toml')
    const pythonManager = has('uv.lock')
      ? 'uv'
      : has('poetry.lock') || pyproject.includes('[tool.poetry]')
        ? 'poetry'
        : has('pdm.lock') || pyproject.includes('[tool.pdm]')
          ? 'pdm'
          : has('pipfile')
            ? 'pipenv'
            : 'python'
    const prefix = pythonPrefix(pythonManager)
    for (const name of extractTomlScriptNames(pyproject)) {
      addTask(tasks, { id: `python:${name}`, name, command: `${prefix}${name}`, ecosystem: `Python · ${pythonManager}`, source: 'pyproject.toml' })
    }
    const entry = has('manage.py') ? 'manage.py runserver' : has('main.py') ? 'main.py' : has('app.py') ? 'app.py' : ''
    const standard: Array<[string, string]> = [['Test', `${prefix}${pythonManager === 'python' ? 'python -m pytest' : 'pytest'}`]]
    if (entry) standard.unshift(['Run', `${prefix}python ${entry}`])
    addStandardTasks(tasks, `Python · ${pythonManager}`, has('pyproject.toml') ? 'pyproject.toml' : 'Python project', standard)
  }

  if (has('cargo.toml')) {
    addStandardTasks(tasks, 'Rust · Cargo', 'Cargo.toml', [
      ['Run', 'cargo run'], ['Test', 'cargo test'], ['Build', 'cargo build'], ['Check', 'cargo check'],
    ])
  }

  if (has('go.mod')) {
    addStandardTasks(tasks, 'Go Modules', 'go.mod', [
      ['Run', 'go run .'], ['Test', 'go test ./...'], ['Build', 'go build ./...'],
    ])
  }

  if (has('pom.xml')) {
    const runner = has(platform === 'win32' ? 'mvnw.cmd' : 'mvnw')
      ? (platform === 'win32' ? 'mvnw.cmd' : './mvnw')
      : 'mvn'
    const commands: Array<[string, string]> = [['Test', `${runner} test`], ['Build', `${runner} package`]]
    if (content('pom.xml').includes('spring-boot')) commands.unshift(['Run', `${runner} spring-boot:run`])
    addStandardTasks(tasks, 'Java · Maven', 'pom.xml', commands)
  }

  const gradleFile = has('build.gradle.kts') ? 'build.gradle.kts' : has('build.gradle') ? 'build.gradle' : ''
  if (gradleFile) {
    const runner = has(platform === 'win32' ? 'gradlew.bat' : 'gradlew')
      ? (platform === 'win32' ? 'gradlew.bat' : './gradlew')
      : 'gradle'
    const gradleContent = content(gradleFile)
    const commands: Array<[string, string]> = [['Test', `${runner} test`], ['Build', `${runner} build`]]
    if (/org\.springframework\.boot|spring-boot/i.test(gradleContent)) commands.unshift(['Run', `${runner} bootRun`])
    else if (/\bapplication\b/.test(gradleContent)) commands.unshift(['Run', `${runner} run`])
    addStandardTasks(tasks, 'Java/Kotlin · Gradle', gradleFile, commands)
  }

  const dotnetProject = files.find(file => /\.(sln|csproj|fsproj)$/i.test(file.name))
  if (dotnetProject) {
    addStandardTasks(tasks, '.NET', dotnetProject.name, [
      ['Run', 'dotnet run'], ['Test', 'dotnet test'], ['Build', 'dotnet build'],
    ])
  }

  if (has('composer.json')) {
    const composer = parseJsonObject(content('composer.json'))
    const scripts = composer?.scripts
    if (scripts && typeof scripts === 'object' && !Array.isArray(scripts)) {
      for (const name of Object.keys(scripts as Record<string, unknown>)) {
        if (!SAFE_TASK_NAME.test(name)) continue
        addTask(tasks, { id: `php:${name}`, name, command: `composer run-script ${name}`, ecosystem: 'PHP · Composer', source: 'composer.json' })
      }
    }
  }

  if (has('mix.exs')) {
    addStandardTasks(tasks, 'Elixir · Mix', 'mix.exs', [
      ['Run', 'mix run --no-halt'], ['Test', 'mix test'], ['Build', 'mix compile'],
    ])
  }

  if (has('pubspec.yaml')) {
    const flutter = /sdk:\s*flutter/.test(content('pubspec.yaml'))
    addStandardTasks(tasks, flutter ? 'Dart · Flutter' : 'Dart · Pub', 'pubspec.yaml', flutter
      ? [['Run', 'flutter run'], ['Test', 'flutter test'], ['Analyze', 'flutter analyze']]
      : [['Run', 'dart run'], ['Test', 'dart test'], ['Analyze', 'dart analyze']])
  }

  if (has('package.swift')) {
    addStandardTasks(tasks, 'Swift Package Manager', 'Package.swift', [
      ['Run', 'swift run'], ['Test', 'swift test'], ['Build', 'swift build'],
    ])
  }

  if (has('build.zig')) {
    addStandardTasks(tasks, 'Zig', 'build.zig', [['Build', 'zig build'], ['Test', 'zig build test']])
  }

  if (has('cmakelists.txt')) {
    addStandardTasks(tasks, 'C/C++ · CMake', 'CMakeLists.txt', [
      ['Configure', 'cmake -S . -B build'], ['Build', 'cmake --build build'], ['Test', 'ctest --test-dir build'],
    ])
  }

  if (has('makefile')) {
    for (const target of extractBuildTargets(content('makefile'), 'make')) {
      addTask(tasks, { id: `make:${target}`, name: target, command: `make ${target}`, ecosystem: 'Make', source: 'Makefile' })
    }
  }

  if (has('justfile')) {
    for (const target of extractBuildTargets(content('justfile'), 'just')) {
      addTask(tasks, { id: `just:${target}`, name: target, command: `just ${target}`, ecosystem: 'Just', source: 'justfile' })
    }
  }

  return tasks
}