import { realpath } from 'fs/promises'
import { getOriginalCwd } from '../bootstrap/state.js'
import { getGlobalConfig, saveGlobalConfig } from './config.js'
import { logForDebugging } from './debug.js'
import {
  detectCurrentRepository,
  parseGitHubRepository,
} from './detectRepository.js'
import { pathExists } from './file.js'
import { getRemoteUrlForDir } from './git/gitFilesystem.js'
import { findGitRoot } from './git.js'

/**
 * Updates the GitHub repository path mapping in global config.
 * Called at startup (fire-and-forget) to track known local paths for repos.
 * This is non-blocking and errors are logged silently.
 *
 * Stores the git root (not cwd) so the mapping always points to the
 * repository root regardless of which subdirectory the user launched from.
 * If the path is already tracked, it is promoted to the front of the list
 * so the most recently used clone appears first.
 */
export async function updateGithubRepoPathMapping(): Promise<void> {
  try {
    const repo = await detectCurrentRepository()
    if (!repo) {
      logForDebugging(
        'Not in a GitHub repository, skipping path mapping update',
      )
      return
    }

    // Use the git root as the canonical path for this repo clone.
    // This ensures we always store the repo root, not an arbitrary subdirectory.
    const cwd = getOriginalCwd()
    const gitRoot = findGitRoot(cwd)
    const basePath = gitRoot ?? cwd

    // Resolve symlinks for canonical storage
    let currentPath: string
    try {
      currentPath = (await realpath(basePath)).normalize('NFC')
    } catch {
      currentPath = basePath
    }

    // Normalize repo key to lowercase for case-insensitive matching
    const repoKey = repo.toLowerCase()

    const config = getGlobalConfig()
    const existingPaths = config.githubRepoPaths?.[repoKey] ?? []

    if (existingPaths[0] === currentPath) {
      // Already at the front — nothing to do
      logForDebugging(`Path ${currentPath} already tracked for repo ${repoKey}`)
      return
    }

    // Remove if present elsewhere (to promote to front), then prepend
    const withoutCurrent = existingPaths.filter(p => p !== currentPath)
    const updatedPaths = [currentPath, ...withoutCurrent]

    saveGlobalConfig(current => ({
      ...current,
      githubRepoPaths: {
        ...current.githubRepoPaths,
        [repoKey]: updatedPaths,
      },
    }))

    logForDebugging(`Added ${currentPath} to tracked paths for repo ${repoKey}`)
  } catch (error) {
    logForDebugging(`Error updating repo path mapping: ${error}`)
    // Silently fail - this is non-blocking startup work
  }
}

/**
 * Gets known local paths for a given GitHub repository.
 * @param repo The repository in "owner/repo" format
 * @returns Array of known absolute paths, or empty array if none
 */
export function getKnownPathsForRepo(repo: string): string[] {
  const config = getGlobalConfig()
  const repoKey = repo.toLowerCase()
  return config.githubRepoPaths?.[repoKey] ?? []
}

/**
 * Filters paths to only those that exist on the filesystem.
 * @param paths Array of absolute paths to check
 * @returns Array of paths that exist
 */
export async function filterExistingPaths(paths: string[]): Promise<string[]> {
  const results = await Promise.all(paths.map(pathExists))
  return paths.filter((_, i) => results[i])
}

/**
 * Validates that a path contains the expected GitHub repository.
 * @param path Absolute path to check
 * @param expectedRepo Expected repository in "owner/repo" format
 * @returns true if the path contains the expected repo, false otherwise
 */
export async function validateRepoAtPath(
  path: string,
  expectedRepo: string,
): Promise<boolean> {
  try {
    const remoteUrl = await getRemoteUrlForDir(path)
    if (!remoteUrl) {
      return false
    }

    const actualRepo = parseGitHubRepository(remoteUrl)
    if (!actualRepo) {
      return false
    }

    // Case-insensitive comparison
    return actualRepo.toLowerCase() === expectedRepo.toLowerCase()
  } catch {
    return false
  }
}

/**
 * Removes a path from the tracked paths for a given repository.
 * Used when a path is found to be invalid during selection.
 * @param repo The repository in "owner/repo" format
 * @param pathToRemove The path to remove from tracking
 */
export function removePathFromRepo(repo: string, pathToRemove: string): void {
  const config = getGlobalConfig()
  const repoKey = repo.toLowerCase()
  const existingPaths = config.githubRepoPaths?.[repoKey] ?? []

  const updatedPaths = existingPaths.filter(path => path !== pathToRemove)

  if (updatedPaths.length === existingPaths.length) {
    // Path wasn't in the list, nothing to do
    return
  }

  const updatedMapping = { ...config.githubRepoPaths }

  if (updatedPaths.length === 0) {
    // Remove the repo key entirely if no paths remain
    delete updatedMapping[repoKey]
  } else {
    updatedMapping[repoKey] = updatedPaths
  }

  saveGlobalConfig(current => ({
    ...current,
    githubRepoPaths: updatedMapping,
  }))

  logForDebugging(
    `Removed ${pathToRemove} from tracked paths for repo ${repoKey}`,
  )
}