/**
 * Block K5 — Fix Agent.
 *
 * Pairs with Gatetest. When a PR has failing checks (or a human pokes the
 * "try fix" button), the fix agent calls `runAndRepair` on Gatetest, which
 * returns file-level before/after patches. For v1 we DO NOT auto-push the
 * patches — instead we post a structured PR comment listing each repair with
 * its reason. A human (or a follow-up agent) applies. This keeps the blast
 * radius bounded while the platform gets its sea legs.
 *
 * Design rules (mirrors heal-bot.ts):
 *   - Never throws. Every DB / network error returns `{ ok: false, summary }`.
 *   - Runs inside the K1 `executeAgentRun` wrapper so the run row carries
 *     status + log + cost.
 *   - Cost: 3¢ flat (Gatetest compute proxy). No Anthropic round-trip.
 *   - No new tables.
 */

import { eq } from "drizzle-orm";
import { db } from "../../db";
import {
  prComments,
  pullRequests,
  repositories,
  users,
} from "../../db/schema";
import { runAndRepair, type GatetestRepair } from "../gatetest-client";
import {
  executeAgentRun,
  startAgentRun,
  type AgentExecutorContext,
} from "../agent-runtime";

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

export interface RunFixAgentArgs {
  repositoryId: string;
  pullRequestId: string;
  triggerBy?: string | null;
  targetGlob?: string | null;
}

export interface RunFixAgentResult {
  ok: boolean;
  summary: string;
  runId: string | null;
}

// ---------------------------------------------------------------------------
// Constants
// ---------------------------------------------------------------------------

/** Per-run Gatetest compute cost proxy, in cents. */
export const FIX_AGENT_COST_CENTS = 3;

/** Max individual repairs to enumerate in the PR comment body. */
export const FIX_AGENT_MAX_REPAIRS_IN_COMMENT = 20;

/** Bot slug — matches the identity K2 will ensureAgentApp for. */
export const FIX_AGENT_SLUG = "agent-fix";

/** Bot username used in comment bodies so humans know who commented. */
export const FIX_AGENT_BOT_USERNAME = "agent-fix[bot]";

// ---------------------------------------------------------------------------
// Pure helpers (unit-testable)
// ---------------------------------------------------------------------------

/**
 * Render the PR comment body for a successful Gatetest run. Deterministic +
 * no I/O so we can exercise it in isolation.
 */
export function renderFixAgentComment(params: {
  passed: boolean;
  totalTests: number;
  failedBefore: number;
  failedAfter: number;
  repairs: GatetestRepair[];
  unfixable: { file: string; reason: string }[];
}): string {
  const { passed, totalTests, failedBefore, failedAfter, repairs, unfixable } =
    params;
  const lines: string[] = [];
  lines.push(`## Fix Agent`);
  lines.push("");
  if (passed) {
    lines.push(
      `Gatetest ran **${totalTests}** test${totalTests === 1 ? "" : "s"} — all passing after ${repairs.length} repair${repairs.length === 1 ? "" : "s"}.`
    );
  } else {
    lines.push(
      `Gatetest proposed **${repairs.length}** repair${repairs.length === 1 ? "" : "s"} (${failedBefore} → ${failedAfter} failing).`
    );
  }
  lines.push("");

  if (repairs.length > 0) {
    lines.push(`### Repairs`);
    const cap = Math.min(repairs.length, FIX_AGENT_MAX_REPAIRS_IN_COMMENT);
    for (let i = 0; i < cap; i++) {
      const r = repairs[i]!;
      lines.push(`- \`${r.file}\` — ${r.reason}`);
    }
    if (repairs.length > cap) {
      lines.push(`- _…and ${repairs.length - cap} more._`);
    }
    lines.push("");
  }

  if (unfixable.length > 0) {
    lines.push(`### Unfixable`);
    for (const u of unfixable.slice(0, FIX_AGENT_MAX_REPAIRS_IN_COMMENT)) {
      lines.push(`- \`${u.file}\` — ${u.reason}`);
    }
    lines.push("");
  }

  lines.push(`_Generated by ${FIX_AGENT_BOT_USERNAME}._`);
  return lines.join("\n");
}

/** Short summary stored in agent_runs.summary. */
export function buildFixAgentSummary(params: {
  offline: boolean;
  passed: boolean;
  failedBefore: number;
  failedAfter: number;
  repairs: number;
}): string {
  if (params.offline) return "gatetest offline; skipped";
  if (params.repairs === 0 && params.failedBefore === 0) {
    return "suite healthy; nothing to fix";
  }
  if (params.repairs === 0) {
    return `${params.failedBefore} failing, 0 repairs proposed`;
  }
  if (params.passed) {
    return `repaired ${params.repairs} (${params.failedBefore} → 0)`;
  }
  return `proposed ${params.repairs} repair${params.repairs === 1 ? "" : "s"} (${params.failedBefore} → ${params.failedAfter})`;
}

// ---------------------------------------------------------------------------
// Internal DB helpers — defensive, never throw.
// ---------------------------------------------------------------------------

interface PrContext {
  prId: string;
  prNumber: number;
  headBranch: string;
  isClosed: boolean;
  isMerged: boolean;
  repoId: string;
  repoName: string;
  ownerUsername: string;
  ownerId: string;
}

async function resolvePrContext(
  pullRequestId: string
): Promise<PrContext | null> {
  try {
    const rows = await db
      .select({
        prId: pullRequests.id,
        prNumber: pullRequests.number,
        headBranch: pullRequests.headBranch,
        state: pullRequests.state,
        mergedAt: pullRequests.mergedAt,
        repoId: repositories.id,
        repoName: repositories.name,
        ownerUsername: users.username,
        ownerId: repositories.ownerId,
      })
      .from(pullRequests)
      .innerJoin(repositories, eq(repositories.id, pullRequests.repositoryId))
      .innerJoin(users, eq(users.id, repositories.ownerId))
      .where(eq(pullRequests.id, pullRequestId))
      .limit(1);
    const row = rows[0];
    if (!row) return null;
    return {
      prId: row.prId,
      prNumber: row.prNumber,
      headBranch: row.headBranch,
      isClosed: row.state !== "open",
      isMerged: row.mergedAt !== null,
      repoId: row.repoId,
      repoName: row.repoName,
      ownerUsername: row.ownerUsername,
      ownerId: row.ownerId,
    };
  } catch (err) {
    console.error("[fix-agent] resolvePrContext:", err);
    return null;
  }
}

/**
 * Pick the author_id for the PR comment. Preference:
 *   1. a "bot" user named FIX_AGENT_BOT_USERNAME,
 *   2. the repo owner.
 */
async function resolveFixAgentAuthorId(
  ownerId: string
): Promise<string | null> {
  try {
    const [bot] = await db
      .select({ id: users.id })
      .from(users)
      .where(eq(users.username, FIX_AGENT_BOT_USERNAME))
      .limit(1);
    if (bot?.id) return bot.id;
  } catch (err) {
    console.error("[fix-agent] bot author lookup:", err);
  }
  return ownerId;
}

// ---------------------------------------------------------------------------
// Entry point
// ---------------------------------------------------------------------------

/**
 * Run the fix agent for a single PR. Never throws.
 *
 * Lifecycle:
 *   1. Open an `agent_runs` row (kind = "fix").
 *   2. Resolve the PR; short-circuit if closed/merged.
 *   3. Call Gatetest `runAndRepair` against the PR head branch.
 *   4. On any result post a PR comment summarising the repairs.
 *   5. Cost: 3¢ flat.
 */
export async function runFixAgent(
  args: RunFixAgentArgs
): Promise<RunFixAgentResult> {
  if (
    !args ||
    typeof args.repositoryId !== "string" ||
    !args.repositoryId ||
    typeof args.pullRequestId !== "string" ||
    !args.pullRequestId
  ) {
    return {
      ok: false,
      summary: "invalid args: missing repositoryId or pullRequestId",
      runId: null,
    };
  }

  const trigger = args.triggerBy ? "manual" : "pr.review_comment";

  const run = await startAgentRun({
    repositoryId: args.repositoryId,
    kind: "fix",
    trigger,
    triggerRef: args.pullRequestId,
  });
  if (!run) {
    return {
      ok: false,
      summary: "could not open agent_runs row",
      runId: null,
    };
  }

  let finalSummary = "not started";

  await executeAgentRun(run.id, async (ctx: AgentExecutorContext) => {
    await ctx.appendLog(
      `[fix-agent] starting run for PR ${args.pullRequestId} (trigger=${trigger})`
    );

    const pr = await resolvePrContext(args.pullRequestId);
    if (!pr) {
      finalSummary = "PR lookup failed";
      await ctx.appendLog("[fix-agent] PR lookup failed; aborting");
      return { ok: false, summary: finalSummary };
    }
    if (pr.repoId !== args.repositoryId) {
      finalSummary = "PR does not belong to repository";
      await ctx.appendLog(
        `[fix-agent] PR ${pr.prId} is in repo ${pr.repoId}, expected ${args.repositoryId}`
      );
      return { ok: false, summary: finalSummary };
    }
    if (pr.isClosed || pr.isMerged) {
      finalSummary = "PR is closed/merged; skipped";
      await ctx.appendLog(`[fix-agent] ${finalSummary}`);
      return { ok: true, summary: finalSummary };
    }

    const repoSlug = `${pr.ownerUsername}/${pr.repoName}`;
    await ctx.appendLog(
      `[fix-agent] calling gatetest.runAndRepair for ${repoSlug}@${pr.headBranch}`
    );

    const result = await runAndRepair({
      repo: repoSlug,
      ref: pr.headBranch,
      targetGlob: args.targetGlob || undefined,
    });
    await ctx.recordCost(0, 0, FIX_AGENT_COST_CENTS);

    if (result.offline) {
      finalSummary = buildFixAgentSummary({
        offline: true,
        passed: false,
        failedBefore: 0,
        failedAfter: 0,
        repairs: 0,
      });
      await ctx.appendLog(`[fix-agent] ${finalSummary}`);
      return { ok: true, summary: finalSummary };
    }

    await ctx.appendLog(
      `[fix-agent] gatetest returned: passed=${result.passed}, failedBefore=${result.failedBefore}, failedAfter=${result.failedAfter}, repairs=${result.repairs.length}`
    );

    // If nothing to say, short-circuit before spamming the PR.
    if (
      result.repairs.length === 0 &&
      result.unfixable.length === 0 &&
      result.failedBefore === 0
    ) {
      finalSummary = buildFixAgentSummary({
        offline: false,
        passed: true,
        failedBefore: 0,
        failedAfter: 0,
        repairs: 0,
      });
      return { ok: true, summary: finalSummary };
    }

    const authorId = await resolveFixAgentAuthorId(pr.ownerId);
    if (!authorId) {
      finalSummary = "no viable author_id for comment";
      await ctx.appendLog(`[fix-agent] ${finalSummary}`);
      return { ok: false, summary: finalSummary };
    }

    const body = renderFixAgentComment({
      passed: result.passed,
      totalTests: result.totalTests,
      failedBefore: result.failedBefore,
      failedAfter: result.failedAfter,
      repairs: result.repairs,
      unfixable: result.unfixable,
    });

    try {
      await db.insert(prComments).values({
        pullRequestId: pr.prId,
        authorId,
        body,
        isAiReview: true,
      });
    } catch (err) {
      finalSummary = `comment insert failed: ${(err as Error).message}`;
      await ctx.appendLog(`[fix-agent] ${finalSummary}`);
      return { ok: false, summary: finalSummary };
    }

    finalSummary = buildFixAgentSummary({
      offline: false,
      passed: result.passed,
      failedBefore: result.failedBefore,
      failedAfter: result.failedAfter,
      repairs: result.repairs.length,
    });
    await ctx.appendLog(`[fix-agent] ${finalSummary}`);
    return { ok: true, summary: finalSummary };
  });

  return { ok: true, summary: finalSummary, runId: run.id };
}

export const __internal = {
  FIX_AGENT_COST_CENTS,
  FIX_AGENT_MAX_REPAIRS_IN_COMMENT,
  resolvePrContext,
  resolveFixAgentAuthorId,
};