/**
 * Git merge operations
 */
import type { SimpleGit } from 'simple-git';
import { spawn } from 'child_process';
import { debug } from '../logger.js';

/**
 * Continue an in-progress rebase without opening an editor.
 * Sets GIT_EDITOR=true then runs git.rebase(['--continue']).
 * WHY: git rebase --continue invokes the configured editor (e.g. nano) to edit the
 * commit message. In non-interactive environments (prr workdir, CI) there is no TTY,
 * so the editor fails with "Standard input is not a terminal" or "problem with the
 * editor 'editor'. Please supply the message using -m or -F". GIT_EDITOR=true is a
 * no-op that exits 0, so git keeps the default (replayed) message. One helper for
 * all rebase --continue call sites keeps behavior consistent.
 */
export async function continueRebase(git: SimpleGit): Promise<void> {
  process.env.GIT_EDITOR = 'true';
  await git.rebase(['--continue']);
}

export async function getConflictedFiles(git: SimpleGit): Promise<string[]> {
  const status = await git.status();
  return status.conflicted || [];
}

export async function abortMerge(git: SimpleGit): Promise<void> {
  try {
    await git.merge(['--abort']);
  } catch {
    // May fail if no merge in progress, ignore
  }
}

/** Run a git command in workdir with stdout/stderr suppressed so we don't flood the user with "fatal: No rebase in progress" etc. */
async function gitQuiet(workdir: string, args: string[]): Promise<{ exitCode: number | null }> {
  return new Promise((resolve) => {
    const proc = spawn('git', args, {
      cwd: workdir,
      stdio: ['ignore', 'ignore', 'ignore'],
    });
    proc.on('close', (code) => resolve({ exitCode: code }));
    proc.on('error', () => resolve({ exitCode: null }));
  });
}

export async function cleanupGitState(git: SimpleGit): Promise<void> {
  debug('Cleaning up git state');

  let workdir: string;
  try {
    workdir = (await git.revparse(['--show-toplevel'])).trim();
  } catch {
    workdir = (git as { _baseDir?: string })._baseDir ?? process.cwd();
  }

  // Run abort/reset/clean with stderr suppressed so user doesn't see "fatal: No merge in progress" etc.
  const m = await gitQuiet(workdir, ['merge', '--abort']);
  if (m.exitCode === 0) debug('Aborted in-progress merge');
  const r = await gitQuiet(workdir, ['rebase', '--abort']);
  if (r.exitCode === 0) debug('Aborted in-progress rebase');
  const c = await gitQuiet(workdir, ['cherry-pick', '--abort']);
  if (c.exitCode === 0) debug('Aborted in-progress cherry-pick');
  const reset = await gitQuiet(workdir, ['reset', '--hard', 'HEAD']);
  if (reset.exitCode === 0) debug('Reset to HEAD');
  const clean = await gitQuiet(workdir, ['clean', '-fd']);
  if (clean.exitCode === 0) debug('Cleaned untracked files');
}

export interface MergeBaseResult {
  success: boolean;
  alreadyUpToDate?: boolean;
  conflictedFiles?: string[];
  error?: string;
}

/**
 * Ensure git user.name and user.email are set in the repo so merge/commit don't fail with
 * "Committer identity unknown". In CI (GITHUB_ACTIONS) use the standard bot identity;
 * otherwise use a safe local default so PRR works without global git config.
 */
export async function ensureGitIdentity(git: SimpleGit): Promise<void> {
  try {
    const name = await git.raw(['config', '--get', 'user.name']).then(s => s?.trim());
    if (name && name.length > 0) return;
  } catch {
    // user.name not set
  }
  const inCI = process.env.GITHUB_ACTIONS === 'true';
  const userName = inCI ? 'github-actions[bot]' : 'PRR';
  const userEmail = inCI ? '41898282+github-actions[bot]@users.noreply.github.com' : 'prr@local';
  await git.raw(['config', 'user.name', userName]);
  await git.raw(['config', 'user.email', userEmail]);
  debug('Set git identity for merge/commit', { userName, userEmail });
}

export interface MergeBaseBranchOptions {
  /** When true, do not short-circuit with merge-base; always run git merge. Use when GitHub reports mergeableState === 'behind' so the source branch is actually updated with the target. */
  forceMerge?: boolean;
  /** When true, use --no-ff so a merge commit is always created when there are incoming commits (never fast-forward). Ensures we have a commit to push and GitHub stops showing "out of date with base branch". */
  noFastForward?: boolean;
}

export async function mergeBaseBranch(
  git: SimpleGit,
  baseBranch: string,
  options?: MergeBaseBranchOptions
): Promise<MergeBaseResult> {
  debug('Merging base branch into PR branch', { baseBranch, forceMerge: options?.forceMerge });
  await ensureGitIdentity(git);

  try {
    // WHY explicit refspec: On --single-branch clones the default fetch config only
    // includes the PR branch; a plain fetch does not update origin/<baseBranch>, so
    // the ref can be stale and the merge-base check incorrectly reports "already up-to-date".
    debug('Fetching base branch with explicit refspec', { baseBranch });
    await git.raw(['remote', 'set-branches', '--add', 'origin', baseBranch]);
    await git.fetch(['origin', `+refs/heads/${baseBranch}:refs/remotes/origin/${baseBranch}`]);
    
    // Check if we're already up-to-date before trying merge (skip when forceMerge: GitHub said "behind")
    if (!options?.forceMerge) {
      const headSha = await git.revparse(['HEAD']);
      const baseSha = await git.revparse([`origin/${baseBranch}`]);
      const mergeBase = await git.raw(['merge-base', 'HEAD', `origin/${baseBranch}`]).then(s => s.trim());
      if (baseSha.trim() === mergeBase) {
        debug('Already up-to-date with base branch');
        return { success: true, alreadyUpToDate: true };
      }
    }
    
    // Try to merge (--no-ff when requested so we always create a merge commit and have something to push)
    const mergeArgs: string[] = [`origin/${baseBranch}`, '--no-edit'];
    if (options?.noFastForward) mergeArgs.push('--no-ff');
    const headBefore = (await git.revparse(['HEAD'])).trim();
    debug('Attempting merge', { noFastForward: options?.noFastForward, headBefore: headBefore.slice(0, 10) });
    const result = await git.merge(mergeArgs);
    const headAfter = (await git.revparse(['HEAD'])).trim();
    debug('Merge completed', { headBefore: headBefore.slice(0, 10), headAfter: headAfter.slice(0, 10), headMoved: headBefore !== headAfter });
    
    // Detect "Already up to date": simple-git's MergeResult (PullResult & MergeDetail)
    // does not store the "Already up to date" text in any parsed field — the line parsers
    // don't match it, so all fields stay at defaults (result: "success", files: [], etc.).
    // JSON.stringify therefore never contains "Already up to date", making the old string
    // check silently fail. Instead, compare HEAD before/after: if HEAD didn't move, the
    // merge was a no-op regardless of what simple-git reports.
    const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
    const textSaysUpToDate = resultStr.includes('Already up to date') || resultStr.includes('Already up-to-date');
    const headDidNotMove = headBefore === headAfter;
    if (textSaysUpToDate || headDidNotMove) {
      debug('Merge says already up-to-date', { textSaysUpToDate, headDidNotMove });
      return { success: true, alreadyUpToDate: true };
    }
    
    debug('Merge successful');
    return { success: true, alreadyUpToDate: false };
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    debug('Merge failed', { error: message });
    
    // "Already up to date" can come as an error in some git versions
    if (message.includes('Already up to date') || message.includes('Already up-to-date')) {
      return { success: true, alreadyUpToDate: true };
    }
    
    // Check for conflicts
    const status = await git.status();
    if (status.conflicted && status.conflicted.length > 0) {
      await abortMerge(git);
      return { 
        success: false, 
        conflictedFiles: status.conflicted,
        error: 'Merge conflicts detected'
      };
    }
    
    await abortMerge(git);
    return { success: false, error: message };
  }
}

export async function startMergeForConflictResolution(
  git: SimpleGit,
  baseBranch: string,
  mergeMessage: string
): Promise<{ conflictedFiles: string[]; error?: string }> {
  debug('Starting merge for conflict resolution', { baseBranch });
  
  try {
    // WHY explicit refspec: Same as mergeBaseBranch — ensure origin/<baseBranch> is
    // up-to-date so the merge we're about to start sees the real remote tip.
    try {
      await git.fetch(['origin', `+refs/heads/${baseBranch}:refs/remotes/origin/${baseBranch}`]);
    } catch {
      // May fail if branch doesn't exist on remote
    }
    
    // Start the merge (will fail with conflicts, that's expected). Only suppress conflict errors;
    // other failures (e.g. ref not found, permission) must propagate so callers don't assume conflicts.
    try {
      await git.merge([`origin/${baseBranch}`, '--no-commit']);
    } catch (err) {
      const msg = err instanceof Error ? err.message : String(err);
      const isConflict = /CONFLICT|conflict|Automatic merge failed|fix conflicts/i.test(msg);
      if (!isConflict) {
        debug('Merge failed (non-conflict), rethrowing', { error: msg });
        throw err;
      }
    }
    
    // Get conflicted files
    const status = await git.status();
    const conflictedFiles = status.conflicted || [];
    
    if (conflictedFiles.length === 0) {
      // No conflicts - either complete the merge or abort if nothing to merge
      if (!status.isClean()) {
        // Staged changes exist from merge - commit them
        const commitResult = await completeMerge(git, mergeMessage);
        if (!commitResult.success) {
          await abortMerge(git);
          return { conflictedFiles: [], error: commitResult.error || 'Failed to complete merge' };
        }
      } else {
        // No changes and no conflicts - merge was a no-op, abort merge state
        await abortMerge(git);
      }
    }

    debug('Merge started, conflicts', { conflictedFiles });
    return { conflictedFiles };
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    return { conflictedFiles: [], error: message };
  }
}

export async function markConflictsResolved(git: SimpleGit, files: string[]): Promise<void> {
  debug('Marking conflicts as resolved', { files });
  for (const file of files) {
    try {
      // Check if file exists in worktree before trying to add
      // WHY: Delete conflicts are resolved by git.rm() in resolveDeleteConflict(),
      // so the file no longer exists. Trying to git.add() a deleted file fails with
      // "pathspec did not match any files". Skip files that don't exist (they're
      // already staged for deletion).
      const { existsSync } = await import('fs');
      const { join } = await import('path');
      const workdir = (await git.revparse(['--show-toplevel'])).trim();
      const fullPath = join(workdir, file);
      if (!existsSync(fullPath)) {
        debug('Skipping deleted file in markConflictsResolved', { file });
        continue;
      }
      await git.add(file);
    } catch (err) {
      // If git.add fails (e.g. file was deleted), skip it
      // Delete conflicts are already handled by resolveDeleteConflict()
      debug('Skipping file in markConflictsResolved (likely deleted)', { file, error: err });
    }
  }
}

/**
 * Resolve the real git directory (handles worktrees where .git is a file with "gitdir: <path>").
 * WHY: In worktrees, join(root, '.git') is a file; we must read it and resolve the path so
 * existsSync(rebase-merge) works. Shared by completeMerge and repository.ts pull conflict loop.
 */
export async function getResolvedGitDir(git: SimpleGit): Promise<string> {
  const { readFileSync, statSync } = await import('fs');
  const { join, resolve: pathResolve, dirname } = await import('path');
  const root = await git.revparse(['--show-toplevel']).catch(() => null);
  const gitDirRaw = root ? join(root.trim(), '.git') : (await git.revparse(['--git-dir'])).trim();
  const rootDir = root ? pathResolve(root.trim()) : null;
  try {
    const stat = statSync(gitDirRaw);
    if (stat.isFile()) {
      const content = readFileSync(gitDirRaw, 'utf-8');
      const m = content.match(/^gitdir:\s*(.+)$/m);
      const target = m ? m[1].trim() : null;
      const base = rootDir ?? pathResolve(dirname(gitDirRaw));
      return target ? pathResolve(base, target) : pathResolve(gitDirRaw);
    }
    return pathResolve(gitDirRaw);
  } catch {
    return pathResolve(gitDirRaw);
  }
}

/**
 * Complete an in-progress merge or rebase after conflicts were resolved.
 * WHY this exists: After resolveConflicts() we've staged the resolution; we must either
 * `rebase --continue` (rebase) or `commit` (merge). Using the wrong one leaves .git/rebase-merge
 * behind and breaks the next push retry.
 */
export async function completeMerge(git: SimpleGit, message: string): Promise<{ success: boolean; error?: string }> {
  debug('Completing merge commit');
  try {
    const { existsSync } = await import('fs');
    const { join } = await import('path');
    const resolvedGitDir = await getResolvedGitDir(git);
    const inRebase = existsSync(join(resolvedGitDir, 'rebase-merge')) || existsSync(join(resolvedGitDir, 'rebase-apply'));

    if (inRebase) {
      debug('In rebase - continuing rebase');
      await continueRebase(git);
    } else {
      debug('In merge - committing');
      await git.commit(message);
    }
    return { success: true };
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    return { success: false, error: errorMessage };
  }
}