import { type Diagnostic, DiagnosticSeverity } from "../config/types.ts";
import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
import { isGlobMatch } from "../pattern-matcher.ts";
import { displayRelativeFilePath, shouldIgnoreLspPath } from "../summary.ts";
import { uriToFile } from "../utils.ts";

export function collectDiagnosticSummaryCounts(
  fileDiags: Map<string, { errors: number; warnings: number }>,
  entry: { uri: string; diagnostics: Diagnostic[] },
  cwd: string,
  excludePatterns?: string[],
): void {
  const file = relativeFilePathFromUri(entry.uri, cwd);
  if (shouldIgnoreLspPath(file, cwd)) return;
  if (excludePatterns?.some((p) => isGlobMatch(file, p))) return;

  const current = fileDiags.get(file) ?? { errors: 0, warnings: 0 };
  for (const diagnostic of entry.diagnostics) {
    if (diagnostic.severity === DiagnosticSeverity.Error) current.errors++;
    else if (diagnostic.severity === DiagnosticSeverity.Warning) current.warnings++;
  }
  fileDiags.set(file, current);
}

export function createOutstandingDiagnosticSummary(
  file: string,
): OutstandingDiagnosticSummaryEntry {
  return {
    file,
    total: 0,
    errors: 0,
    warnings: 0,
    information: 0,
    hints: 0,
  };
}

export function accumulateOutstandingDiagnostics(
  current: OutstandingDiagnosticSummaryEntry,
  diagnostics: Diagnostic[],
  maxSeverity: number,
): OutstandingDiagnosticSummaryEntry {
  const next = { ...current };

  for (const diagnostic of diagnostics) {
    if (!isDiagnosticWithinThreshold(diagnostic, maxSeverity)) continue;

    next.total++;
    incrementOutstandingDiagnosticCount(next, diagnostic.severity);
  }

  return next;
}

export function relativeFilePathFromUri(uri: string, cwd: string): string {
  return displayRelativeFilePath(uriToFile(uri), cwd);
}

function isDiagnosticWithinThreshold(
  diagnostic: Diagnostic,
  maxSeverity: number,
): diagnostic is Diagnostic & { severity: number } {
  return diagnostic.severity !== undefined && diagnostic.severity <= maxSeverity;
}

function incrementOutstandingDiagnosticCount(
  entry: OutstandingDiagnosticSummaryEntry,
  severity: number,
): void {
  if (severity === DiagnosticSeverity.Error) entry.errors++;
  else if (severity === DiagnosticSeverity.Warning) entry.warnings++;
  else if (severity === DiagnosticSeverity.Information) entry.information++;
  else if (severity === DiagnosticSeverity.Hint) entry.hints++;
}