import type { FileDiffData, DiffComment, AnnotationSide, CommentAnnotation } from "./types";

/**
 * Format line range for display (e.g., "L10" or "L10-15")
 */
export function formatLineRange(startLine: number, endLine: number): string {
  return startLine === endLine ? `L${startLine}` : `L${startLine}-${endLine}`;
}

/**
 * Frontend types that mirror backend FileMutation
 */
export interface FileMutation {
  type: "create" | "replace" | "patch" | "delete" | "rename";
  content?: string;
  old_content?: string;
  new_content?: string;
  diff?: string;
  new_path?: string;
  start_line?: number;
  end_line?: number;
}

export interface ModifyFilePayload {
  file_path: string;
  mutations: FileMutation[];
}

/**
 * Normalize a diff string by ensuring it has proper headers.
 * Required because backend diffs may not include full git headers.
 */
export function normalizeDiffString(diff: string, filePath: string): string {
  if (!diff) return "";

  const trimmed = diff.trim();

  // Check if the diff already has headers
  if (trimmed.startsWith("diff --git")) {
    return trimmed;
  }

  // Check if it has file headers but not diff header
  const hasFileHeaders = trimmed.includes("---") && trimmed.includes("+++");

  if (hasFileHeaders) {
    // Add just the diff header
    return `diff --git a/${filePath} b/${filePath}\n${trimmed}`;
  }

  // Add minimal headers
  const headers = [
    `diff --git a/${filePath} b/${filePath}`,
    `--- a/${filePath}`,
    `+++ b/${filePath}`,
  ];
  return headers.join("\n") + "\n" + trimmed;
}

/**
 * Transform a backend FileMutation to FileDiffData for @pierre/diffs.
 * The DiffViewer component handles diff generation from content using the library.
 */
export function transformFileMutation(filePath: string, mutation: FileMutation): FileDiffData {
  return {
    filePath: mutation.new_path || filePath,
    oldContent: mutation.old_content || "",
    newContent: mutation.new_content || mutation.content || "",
    diff: mutation.diff ? normalizeDiffString(mutation.diff, filePath) : undefined,
    additions: 0,
    deletions: 0,
  };
}

/**
 * Transform a git status diff string to FileDiffData.
 * Language detection is handled automatically by the library.
 */
export function transformGitDiff(
  filePath: string,
  diff: string,
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  _status: "A" | "M" | "D" | "??" | string,
): FileDiffData {
  return {
    filePath,
    oldContent: "",
    newContent: "",
    diff: normalizeDiffString(diff, filePath),
    additions: 0,
    deletions: 0,
  };
}

/**
 * Convert DiffComment[] to @pierre/diffs DiffLineAnnotation[]
 */
export function commentsToAnnotations(comments: DiffComment[]): CommentAnnotation[] {
  return comments.map((comment) => ({
    side: comment.side,
    lineNumber: comment.endLine, // Anchor at the end of the range
    metadata: {
      comment,
      isEditing: false,
    },
  }));
}

function isDiffHeader(line: string): boolean {
  return line.startsWith("diff --git") || line.startsWith("---") || line.startsWith("+++");
}

function isInRange(lineNum: number, startLine: number, endLine: number): boolean {
  return lineNum >= startLine && lineNum <= endLine;
}

type DiffLineCounters = { currentOldLine: number; currentNewLine: number };

function processHunkHeader(line: string, counters: DiffLineCounters): boolean {
  const hunkMatch = line.match(/^@@\s*-(\d+)(?:,\d+)?\s*\+(\d+)(?:,\d+)?\s*@@/);
  if (!hunkMatch) return false;
  counters.currentOldLine = parseInt(hunkMatch[1], 10);
  counters.currentNewLine = parseInt(hunkMatch[2], 10);
  return true;
}

type ProcessDiffLineParams = {
  line: string;
  counters: DiffLineCounters;
  startLine: number;
  endLine: number;
  side: AnnotationSide;
  resultLines: string[];
};

function processDiffLine({
  line,
  counters,
  startLine,
  endLine,
  side,
  resultLines,
}: ProcessDiffLineParams): void {
  if (line.startsWith("+")) {
    if (side === "additions" && isInRange(counters.currentNewLine, startLine, endLine)) {
      resultLines.push(line.substring(1));
    }
    counters.currentNewLine++;
  } else if (line.startsWith("-")) {
    if (side === "deletions" && isInRange(counters.currentOldLine, startLine, endLine)) {
      resultLines.push(line.substring(1));
    }
    counters.currentOldLine++;
  } else if (line.startsWith(" ") || (!line.startsWith("@") && line !== "")) {
    const content = line.startsWith(" ") ? line.substring(1) : line;
    const lineNum = side === "additions" ? counters.currentNewLine : counters.currentOldLine;
    if (isInRange(lineNum, startLine, endLine)) resultLines.push(content);
    counters.currentOldLine++;
    counters.currentNewLine++;
  }
}

/**
 * Extract code content from diff for a line range
 */
export function extractCodeFromDiff(
  diff: string,
  startLine: number,
  endLine: number,
  side: AnnotationSide,
): string {
  const lines = diff.split("\n");
  const resultLines: string[] = [];
  const counters: DiffLineCounters = { currentOldLine: 0, currentNewLine: 0 };

  for (const line of lines) {
    if (processHunkHeader(line, counters)) continue;
    if (isDiffHeader(line)) continue;
    processDiffLine({ line, counters, startLine, endLine, side, resultLines });
  }

  return resultLines.join("\n");
}

/**
 * Extract code content from full file content for a line range
 */
export function extractCodeFromContent(
  content: string,
  startLine: number,
  endLine: number,
): string {
  const lines = content.split("\n");
  return lines.slice(startLine - 1, endLine).join("\n");
}

/**
 * Compute simple line-level diff stats between two strings.
 * Returns the number of added and deleted lines.
 */
export function computeLineDiffStats(
  original: string,
  current: string,
): { additions: number; deletions: number } {
  const originalLines = original.split("\n");
  const currentLines = current.split("\n");
  let additions = 0;
  let deletions = 0;
  const maxLen = Math.max(originalLines.length, currentLines.length);
  for (let i = 0; i < maxLen; i++) {
    const origLine = originalLines[i];
    const currLine = currentLines[i];
    if (origLine === undefined && currLine !== undefined) additions++;
    else if (origLine !== undefined && currLine === undefined) deletions++;
    else if (origLine !== currLine) {
      additions++;
      deletions++;
    }
  }
  return { additions, deletions };
}