import type { IntegrationEvent, IntegrationFilters } from "~/lib/integrations";

export type EventTone = "good" | "bad" | "info" | "neutral";

/** One forge event reduced to what a chat message needs; formatters only ever see this. */
export type EventSummary = {
  category: IntegrationEvent;
  event: string;
  action: string;
  repo: string;
  repoUrl: string;
  title: string;
  url: string;
  actor: string | null;
  text: string | null;
  tone: EventTone;
  branch: string | null;
  draft: boolean;
  conclusion: string | null;
  fields: Array<{ label: string; value: string }>;
};

export type RepoContext = { fullName: string; url: string; defaultBranch: string };

const MAX_TEXT = 500;
const MAX_COMMIT_LINES = 5;
const SHORT_SHA = 7;
const PULL_ACTIONS = new Set(["opened", "reopened", "closed", "ready_for_review"]);
const ISSUE_ACTIONS = new Set(["opened", "closed", "reopened"]);
const QUIET_CONCLUSIONS = new Set(["success", "skipped", "neutral"]);

type Json = Record<string, unknown>;

function obj(value: unknown): Json {
  return value && typeof value === "object" && !Array.isArray(value) ? (value as Json) : {};
}

function str(value: unknown): string | null {
  return typeof value === "string" && value.length > 0 ? value : null;
}

function clip(text: string | null, max = MAX_TEXT): string | null {
  if (!text) return null;
  const trimmed = text.trim();
  if (!trimmed) return null;
  return trimmed.length > max ? `${trimmed.slice(0, max - 1)}…` : trimmed;
}

function actorOf(payload: Json): string | null {
  return str(obj(payload.sender).login) ?? str(obj(payload.pusher).name);
}

function base(
  repo: RepoContext,
  event: string,
  payload: Json,
): Omit<EventSummary, "category" | "title" | "url" | "tone"> {
  return {
    event,
    action: str(payload.action) ?? "",
    repo: repo.fullName,
    repoUrl: repo.url,
    actor: actorOf(payload),
    text: null,
    branch: null,
    draft: false,
    conclusion: null,
    fields: [],
  };
}

function summarizePush(repo: RepoContext, payload: Json): EventSummary | null {
  const ref = str(payload.ref) ?? "";
  if (!ref.startsWith("refs/heads/") || payload.deleted === true) return null;
  const branch = ref.slice("refs/heads/".length);
  const commits = Array.isArray(payload.commits) ? payload.commits.map(obj) : [];
  if (commits.length === 0) return null;
  const lines = commits.slice(0, MAX_COMMIT_LINES).map((commit) => {
    const sha = (str(commit.id) ?? "").slice(0, SHORT_SHA);
    const message = (str(commit.message) ?? "").split("\n", 1)[0];
    return `${sha} ${message}`;
  });
  if (commits.length > MAX_COMMIT_LINES) lines.push(`… and ${commits.length - MAX_COMMIT_LINES} more`);
  const summary = base(repo, "push", payload);
  const noun = commits.length === 1 ? "commit" : "commits";
  return {
    ...summary,
    category: "push",
    title: `${summary.actor ?? "Someone"} pushed ${commits.length} ${noun} to ${branch}`,
    url: `${repo.url}/commits/${encodeURIComponent(branch)}`,
    tone: "neutral",
    branch,
    text: clip(lines.join("\n")),
  };
}

function summarizePull(repo: RepoContext, payload: Json): EventSummary | null {
  const action = str(payload.action) ?? "";
  if (!PULL_ACTIONS.has(action)) return null;
  const pull = obj(payload.pull_request);
  const number = Number(pull.number ?? payload.number);
  const merged = pull.merged === true;
  const verb = merged ? "merged" : action === "ready_for_review" ? "marked ready" : action;
  const summary = base(repo, "pull_request", payload);
  const title = str(pull.title);
  const head = str(obj(pull.head).ref);
  const baseRef = str(obj(pull.base).ref);
  return {
    ...summary,
    action: merged ? "merged" : action,
    category: "pull_request",
    title: `Pull request #${number} ${verb}${title ? `: ${title}` : ""}`,
    url: str(pull.html_url) ?? `${repo.url}/pull/${number}`,
    tone: merged ? "good" : action === "closed" ? "bad" : "info",
    branch: head,
    draft: pull.draft === true,
    text: action === "opened" ? clip(str(pull.body)) : null,
    fields: head && baseRef ? [{ label: "Branch", value: `${head} → ${baseRef}` }] : [],
  };
}

function summarizeReview(repo: RepoContext, payload: Json): EventSummary | null {
  if (payload.action !== "submitted") return null;
  const review = obj(payload.review);
  const pull = obj(payload.pull_request);
  const state = str(review.state) ?? "commented";
  const number = Number(pull.number);
  const summary = base(repo, "pull_request_review", payload);
  return {
    ...summary,
    action: state,
    category: "review",
    title: `${summary.actor ?? "Someone"} ${state.replaceAll("_", " ")} pull request #${number}`,
    url: str(pull.html_url) ?? `${repo.url}/pull/${number}`,
    tone: state === "approved" ? "good" : state === "changes_requested" ? "bad" : "neutral",
    text: clip(str(review.body)),
  };
}

function summarizeRun(repo: RepoContext, payload: Json): EventSummary | null {
  const run = obj(payload.workflow_run);
  if (payload.action !== "completed") return null;
  const conclusion = str(run.conclusion) ?? "unknown";
  const branch = str(run.head_branch);
  const summary = base(repo, "workflow_run", payload);
  return {
    ...summary,
    category: "ci",
    action: conclusion,
    title: `${str(run.name) ?? "Workflow"} #${Number(run.run_number)} ${conclusion}${branch ? ` on ${branch}` : ""}`,
    url: str(run.html_url) ?? `${repo.url}/actions`,
    tone: conclusion === "success" ? "good" : QUIET_CONCLUSIONS.has(conclusion) ? "neutral" : "bad",
    branch,
    conclusion,
    fields: str(run.head_sha) ? [{ label: "Commit", value: (str(run.head_sha) ?? "").slice(0, SHORT_SHA) }] : [],
  };
}

function summarizeRelease(repo: RepoContext, payload: Json): EventSummary | null {
  if (payload.action !== "published") return null;
  const release = obj(payload.release);
  const tag = str(release.tag_name) ?? "";
  const name = str(release.name) ?? tag;
  const summary = base(repo, "release", payload);
  return {
    ...summary,
    category: "release",
    title: `Released ${name}${release.prerelease === true ? " (pre-release)" : ""}`,
    url: str(release.html_url) ?? `${repo.url}/releases`,
    tone: "good",
    text: clip(str(release.body)),
    fields: [{ label: "Tag", value: tag }],
  };
}

function summarizeIssue(repo: RepoContext, payload: Json): EventSummary | null {
  const action = str(payload.action) ?? "";
  if (!ISSUE_ACTIONS.has(action)) return null;
  const issue = obj(payload.issue);
  const number = Number(issue.number);
  const summary = base(repo, "issues", payload);
  return {
    ...summary,
    category: "issues",
    title: `Issue #${number} ${action}: ${str(issue.title) ?? ""}`.trim(),
    url: str(issue.html_url) ?? `${repo.url}/issues/${number}`,
    tone: action === "closed" ? "neutral" : "info",
    text: action === "opened" ? clip(str(issue.body)) : null,
  };
}

/** Normalizes a forge webhook (or a relayed `github.*` event) into a summary, or null when it is not worth a message. */
export function summarizeEvent(event: string, payload: Json, repo: RepoContext): EventSummary | null {
  if (event.startsWith("github.")) {
    const summary = base(repo, event, payload);
    return {
      ...summary,
      category: "github",
      title: `GitHub ${event.slice("github.".length)}${summary.action ? ` ${summary.action}` : ""}`,
      url: str(obj(payload.repository).html_url) ?? repo.url,
      tone: "neutral",
    };
  }
  switch (event) {
    case "push":
      return summarizePush(repo, payload);
    case "pull_request":
      return summarizePull(repo, payload);
    case "pull_request_review":
      return summarizeReview(repo, payload);
    case "workflow_run":
      return summarizeRun(repo, payload);
    case "release":
      return summarizeRelease(repo, payload);
    case "issues":
      return summarizeIssue(repo, payload);
    default:
      return null;
  }
}

const MAX_WILDCARDS = 8;
const NEVER = /$^/;

function globToRegExp(raw: string): RegExp {
  if ((raw.match(/\*/g)?.length ?? 0) > MAX_WILDCARDS) return NEVER;
  const pattern = raw.replace(/\*{3,}/g, "**").replace(/(\*\*\/)+/g, "**/");
  const escaped = pattern
    .replace(/[.+?^${}()|[\]\\]/g, "\\$&")
    .replaceAll("**", "\u0000")
    .replaceAll("*", "[^/]*");
  return new RegExp(`^${escaped.replaceAll("\u0000", ".*").replace(/(\.\*)+/g, ".*")}$`);
}

export function branchMatches(branch: string, patterns: string[], defaultBranch: string): boolean {
  if (patterns.length === 0) return branch === defaultBranch;
  return patterns.some((pattern) => globToRegExp(pattern.trim()).test(branch));
}

function isBot(actor: string | null): boolean {
  return actor !== null && (/\[bot\]$/i.test(actor) || /-bot$/i.test(actor));
}

/** Default-quiet routing: category toggles, draft/bot suppression, branch scoping and failures-only CI. */
export function passesFilters(
  summary: EventSummary,
  events: string[],
  filters: IntegrationFilters,
  defaultBranch: string,
): boolean {
  if (!events.includes(summary.category)) return false;
  if (filters.skipBots && isBot(summary.actor)) return false;
  if (filters.skipDrafts && summary.draft) return false;
  if (summary.category === "ci" && filters.ciFailuresOnly && QUIET_CONCLUSIONS.has(summary.conclusion ?? "")) {
    return false;
  }
  if ((summary.category === "push" || summary.category === "ci") && summary.branch) {
    return branchMatches(summary.branch, filters.branches, defaultBranch);
  }
  return true;
}