/**
 * Lock file utilities for conflict detection
 */
import { existsSync, readFileSync } from 'fs';
import { join } from 'path';

export function isLockFile(filepath: string): boolean {
  return /(?:bun\.lockb?|package-lock\.json|yarn\.lock|pnpm-lock\.yaml|Gemfile\.lock|Pipfile\.lock|poetry\.lock|composer\.lock|cargo\.lock)$/i.test(filepath);
}

export function getLockFileInfo(filepath: string): { deletePattern: string; regenerateCmd: string } | null {
  const lower = filepath.toLowerCase();
  if (lower.endsWith('bun.lock')) return { deletePattern: '**/bun.lock', regenerateCmd: 'bun install' };
  if (lower.endsWith('bun.lockb')) return { deletePattern: '**/bun.lockb', regenerateCmd: 'bun install' };
  if (lower.endsWith('package-lock.json')) return { deletePattern: '**/package-lock.json', regenerateCmd: 'npm install' };
  if (lower.endsWith('yarn.lock')) return { deletePattern: '**/yarn.lock', regenerateCmd: 'yarn install' };
  if (lower.endsWith('pnpm-lock.yaml')) return { deletePattern: '**/pnpm-lock.yaml', regenerateCmd: 'pnpm install' };
  if (lower.endsWith('gemfile.lock')) return { deletePattern: '**/Gemfile.lock', regenerateCmd: 'bundle install' };
  if (lower.endsWith('pipfile.lock')) return { deletePattern: '**/Pipfile.lock', regenerateCmd: 'pipenv lock' };
  if (lower.endsWith('poetry.lock')) return { deletePattern: '**/poetry.lock', regenerateCmd: 'poetry lock' };
  if (lower.endsWith('composer.lock')) return { deletePattern: '**/composer.lock', regenerateCmd: 'composer install' };
  if (lower.endsWith('cargo.lock')) return { deletePattern: '**/Cargo.lock', regenerateCmd: 'cargo build' };
  return null;
}

/** Trim leading whitespace so indented conflict markers still match (merge tools rarely indent, but be safe). */
function t(line: string): string {
  return line.trimStart();
}

export function isGitConflictOpenLine(trimmed: string): boolean {
  return trimmed.startsWith('<<<<<<<');
}

export function isGitConflictCloseLine(trimmed: string): boolean {
  return trimmed.startsWith('>>>>>>>');
}

/** True when the line is Git's middle separator only: exactly seven `=` and optional trailing spaces. */
export function isGitConflictMiddleLine(trimmed: string): boolean {
  return /^={7}\s*$/.test(trimmed);
}

/**
 * One-line doc heading above a setext `=======` underline (narrow).
 * WHY: Orphan `=======` between normal sentences (failed merge) must still count as conflict.
 */
function looksLikeSetextHeadingLine(s: string): boolean {
  const line = s.trim();
  if (!line || line.length > 120) return false;
  if (looksLikeCodeOrStructuredLine(line)) return false;
  if (isGitConflictOpenLine(line) || isGitConflictCloseLine(line) || isGitConflictMiddleLine(line)) return false;
  // Multi-word Title Case (e.g. "API Overview")
  if (/^[A-Z][a-z]+(?:\s+[A-Z][a-z]+)+\s*$/.test(line)) return true;
  // Single capitalized word / phrase token (e.g. "Roadmap", "v2")
  if (/^[A-Z][a-zA-Z0-9.-]{0,48}$/.test(line)) return true;
  // Short ALL CAPS heading
  if (/^[A-Z][A-Z0-9 ,&:+\-]{1,50}$/.test(line) && !/[a-z]/.test(line.slice(1))) return true;
  return false;
}

/**
 * Heuristic: line looks like source, config, or structured markup — not a one-line doc heading.
 */
function looksLikeCodeOrStructuredLine(s: string): boolean {
  if (/^(import|export|default|from)\b/.test(s)) return true;
  if (/^(const|let|var|function|class|interface|type|enum|namespace)\b/.test(s)) return true;
  if (/^(return|if|else|for|while|do|switch|case|break|continue|try|catch|finally|throw|new|await|async)\b/.test(s)) return true;
  if (/^(def|fn|pub|use|mod|impl|trait)\b/.test(s)) return true;
  if (/^#include\b|^package\b|^module\b/.test(s)) return true;
  if (/^(describe|it|test|expect|beforeEach|afterEach)\b/.test(s)) return true;
  if (/^\s*[`]{3,}/.test(s) || /^```/.test(s.trimStart())) return true;
  if (/^\s*[-*]\s+\[[ x]\]\s/i.test(s)) return true;
  if (/[{][$\w]|[};]\s*$|=>|::|<\/|^\s*[-+*]\s+`/.test(s)) return true;
  if (/^\s*[!%/<>&|[\]]/.test(s)) return true;
  return false;
}

/**
 * Single full line `=======` between a short non-code line and following body — typical setext / doc divider.
 * Only used when there is **no** `<<<<<<<` / `>>>>>>>` anywhere (those always imply conflict).
 */
function isPlausibleMarkdownSevenEqualsDivider(lines: string[], midIdx: number): boolean {
  let p = midIdx - 1;
  while (p >= 0 && lines[p]!.trim() === '') p--;
  if (p < 0) return false;
  const prev = lines[p]!.trim();
  if (!prev || prev.length > 200) return false;
  if (!looksLikeSetextHeadingLine(prev)) return false;
  let n = midIdx + 1;
  while (n < lines.length && lines[n]!.trim() === '') n++;
  if (n >= lines.length) return false;
  const next = lines[n]!.trim();
  if (!next) return false;
  if (isGitConflictOpenLine(next) || isGitConflictCloseLine(next)) return false;
  if (isGitConflictMiddleLine(next)) return false;
  return true;
}

/**
 * True when the file still contains git merge conflict markers or failed cleanup leftovers.
 *
 * Detects:
 * - **`<<<<<<<`** openers (standard regions)
 * - **`>>>>>>>`** closers — including orphan closers from partial cleanup
 * - **`=======`** middle lines: orphan middle, or **multiple** middle-only lines (broken merge); a **single** lone
 *   middle line between a short non-code line and body is treated as markdown setext / divider (not conflict)
 *
 * Uses **trimStart** per line so slightly indented markers still count.
 */
export function hasConflictMarkers(content: string): boolean {
  const lines = content.split('\n');
  let sawOpen = false;
  let sawClose = false;
  const middleIndices: number[] = [];

  for (let i = 0; i < lines.length; i++) {
    const line = t(lines[i]!);
    if (isGitConflictOpenLine(line)) sawOpen = true;
    else if (isGitConflictCloseLine(line)) sawClose = true;
    else if (isGitConflictMiddleLine(line)) middleIndices.push(i);
  }

  if (sawOpen || sawClose) return true;
  if (middleIndices.length === 0) return false;
  if (middleIndices.length >= 2) return true;
  const onlyMid = middleIndices[0]!;
  if (isPlausibleMarkdownSevenEqualsDivider(lines, onlyMid)) return false;
  return true;
}

/**
 * True if a `<<<<<<<` appears again before the first `=======` for that region (nested / botched merge).
 * WHY: Audits showed CHANGELOG prompts with back-to-back `<<<<<<< HEAD` — LLM resolution is unreliable;
 * deterministic keep-ours may also fail; warn the operator early.
 */
export function hasNestedConflictMarkers(content: string): boolean {
  const lines = content.split('\n');
  for (let i = 0; i < lines.length; i++) {
    const ti = t(lines[i]!);
    if (!isGitConflictOpenLine(ti)) continue;
    for (let j = i + 1; j < lines.length; j++) {
      const tj = t(lines[j]!);
      if (isGitConflictMiddleLine(tj) || isGitConflictCloseLine(tj)) break;
      if (isGitConflictOpenLine(tj)) return true;
    }
  }
  return false;
}

/**
 * True only when git **open or close** conflict markers appear (`<<<<<<<` / `>>>>>>>`).
 * WHY: `hasConflictMarkers` also flags standalone `=======` lines; markdown (ROADMAP, CHANGELOG)
 * often uses seven equals. Unmerged **index stage-2** blobs from Git should not contain open/close
 * markers — if they do, the blob is corrupt or not a normal ours side. Use this to validate
 * `git show :2:path` before writing deterministic keep-ours (see audit Cycle 66).
 */
export function hasGitConflictOpenOrCloseMarkers(content: string): boolean {
  for (const line of content.split('\n')) {
    const lineTrim = t(line);
    if (isGitConflictOpenLine(lineTrim) || isGitConflictCloseLine(lineTrim)) return true;
  }
  return false;
}

export function findFilesWithConflictMarkers(workdir: string, files: string[]): string[] {
  if (!workdir) return [];

  const conflicted: string[] = [];
  for (const file of files) {
    const fullPath = join(workdir, file);
    if (existsSync(fullPath)) {
      try {
        const content = readFileSync(fullPath, 'utf-8');
        if (hasConflictMarkers(content)) {
          conflicted.push(file);
        }
      } catch {
        // Skip files that can't be read
      }
    }
  }
  return conflicted;
}