/**
 * Block K7 — Deploy Watcher Agent.
 *
 * Fires after Crontech reports a deployment for a commit. Watches the
 * deployment and consumes prod error signals (ingested via K9) for the same
 * commit. If the deploy fails outright, OR if the error-signal count exceeds
 * ERROR_THRESHOLD within the watch window, the watcher calls Crontech's
 * `rollbackDeployment` and opens a P0 incident issue on the repo.
 *
 * Design rules (mirrors heal-bot.ts + fix-agent.ts):
 *   - Never throws. Every DB / network error returns `{ ok, summary }`.
 *   - Runs inside K1's `executeAgentRun` wrapper.
 *   - Cost: 2¢ flat per watch (Crontech compute proxy).
 *   - No new tables — consumes `deployments`, `prod_signals`, `issues`.
 */

import { and, eq, gte, sql } from "drizzle-orm";
import { db } from "../../db";
import {
  issues,
  repositories,
  users,
} from "../../db/schema";
import {
  rollbackDeployment,
  watchDeployment,
  type DeployWatchResult,
} from "../crontech-client";
import {
  executeAgentRun,
  startAgentRun,
  type AgentExecutorContext,
} from "../agent-runtime";

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

export interface RunDeployWatcherArgs {
  repositoryId: string;
  deployId: string;
  commitSha: string;
  triggerBy?: string | null;
}

export interface RunDeployWatcherResult {
  ok: boolean;
  summary: string;
  runId: string | null;
  rolledBack: boolean;
  incidentIssueNumber: number | null;
}

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

export const DEPLOY_WATCHER_COST_CENTS = 2;

/** Error signals of (error|critical) severity needed to auto-rollback. */
export const DEPLOY_WATCHER_ERROR_THRESHOLD = 5;

/** How long to watch before declaring the deploy healthy. */
export const DEPLOY_WATCHER_WINDOW_MS = 15 * 60 * 1000;

/** Poll interval inside the window. */
export const DEPLOY_WATCHER_POLL_MS = 30 * 1000;

export const DEPLOY_WATCHER_SLUG = "agent-deploy-watcher";
export const DEPLOY_WATCHER_BOT_USERNAME = "agent-deploy-watcher[bot]";

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

/**
 * Is the given deploy-watch result a rollback trigger? Either the deploy
 * itself failed, or the error-signal threshold was breached.
 */
export function shouldRollback(params: {
  watchResult: DeployWatchResult;
  errorSignalCount: number;
  threshold: number;
}): { rollback: boolean; reason: string } {
  if (params.watchResult.finalStatus === "failed") {
    return { rollback: true, reason: "deploy reported status=failed" };
  }
  if (params.watchResult.finalStatus === "rolled_back") {
    return { rollback: false, reason: "deploy already rolled back" };
  }
  if (params.errorSignalCount >= params.threshold) {
    return {
      rollback: true,
      reason: `${params.errorSignalCount} error signals ≥ threshold ${params.threshold}`,
    };
  }
  return { rollback: false, reason: "deploy healthy" };
}

/**
 * Deterministic P0 incident issue body. Lists the top error hashes + a link
 * back to the commit.
 */
export function renderIncidentIssueBody(params: {
  commitSha: string;
  ownerUsername: string;
  repoName: string;
  deployId: string;
  reason: string;
  topErrors: Array<{ hash: string; message: string; count: number }>;
}): string {
  const {
    commitSha,
    ownerUsername,
    repoName,
    deployId,
    reason,
    topErrors,
  } = params;
  const shortSha = commitSha.slice(0, 7);
  const lines: string[] = [];
  lines.push(`**Automatic regression rollback triggered by the deploy-watcher agent.**`);
  lines.push("");
  lines.push(`- **Commit:** [\`${shortSha}\`](/${ownerUsername}/${repoName}/commit/${commitSha})`);
  lines.push(`- **Deployment:** \`${deployId}\``);
  lines.push(`- **Reason:** ${reason}`);
  lines.push("");
  if (topErrors.length > 0) {
    lines.push(`### Top errors`);
    lines.push("");
    lines.push("| Hash | Count | Message |");
    lines.push("| --- | ---: | --- |");
    for (const e of topErrors.slice(0, 10)) {
      const safeMsg = e.message.replace(/\|/g, "\\|").slice(0, 120);
      lines.push(`| \`${e.hash}\` | ${e.count} | ${safeMsg} |`);
    }
    lines.push("");
  }
  lines.push(`_Generated by ${DEPLOY_WATCHER_BOT_USERNAME}._`);
  return lines.join("\n");
}

export function buildDeployWatcherSummary(params: {
  offline: boolean;
  rolledBack: boolean;
  reason: string;
  incidentIssueNumber: number | null;
  watchedForMs: number;
  errorSignalCount: number;
}): string {
  if (params.offline) return "crontech offline; watch skipped";
  if (params.rolledBack) {
    const issueLabel =
      params.incidentIssueNumber !== null
        ? `#${params.incidentIssueNumber}`
        : "(unknown issue)";
    return `ROLLED BACK — ${params.reason}; opened ${issueLabel}`;
  }
  const secs = Math.round(params.watchedForMs / 1000);
  return `deploy healthy — watched ${secs}s, ${params.errorSignalCount} signal(s)`;
}

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

interface RepoContext {
  repoId: string;
  repoName: string;
  ownerUsername: string;
  ownerId: string;
}

async function resolveRepoContext(
  repositoryId: string
): Promise<RepoContext | null> {
  try {
    const rows = await db
      .select({
        repoId: repositories.id,
        repoName: repositories.name,
        ownerUsername: users.username,
        ownerId: repositories.ownerId,
      })
      .from(repositories)
      .innerJoin(users, eq(users.id, repositories.ownerId))
      .where(eq(repositories.id, repositoryId))
      .limit(1);
    const row = rows[0];
    if (!row) return null;
    return row;
  } catch (err) {
    console.error("[deploy-watcher] resolveRepoContext:", err);
    return null;
  }
}

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

interface SignalAggregate {
  hash: string;
  message: string;
  count: number;
  severity: string;
}

/**
 * Count error/critical signals for the given commit that have been recorded
 * since `since`, and return the top-N aggregated signals for the incident
 * body.
 *
 * Uses raw sql because we filter on severity in SQL for efficiency.
 */
async function countAndTopErrors(
  repositoryId: string,
  commitSha: string,
  since: Date
): Promise<{ count: number; top: SignalAggregate[] }> {
  try {
    const rows = (await db.execute(sql`
      SELECT error_hash, message, count, severity
      FROM prod_signals
      WHERE repository_id = ${repositoryId}
        AND commit_sha = ${commitSha.toLowerCase()}
        AND severity IN ('error', 'critical')
        AND last_seen >= ${since.toISOString()}
      ORDER BY count DESC
      LIMIT 25
    `)) as unknown as Array<Record<string, unknown>>;
    if (!Array.isArray(rows)) return { count: 0, top: [] };
    const list = rows.map((r) => ({
      hash: String(r.error_hash ?? ""),
      message: String(r.message ?? ""),
      count: Number(r.count ?? 1),
      severity: String(r.severity ?? "error"),
    }));
    // Total count = sum of counts (each signal row is one distinct error,
    // bumped per occurrence).
    const total = list.reduce((acc, r) => acc + r.count, 0);
    return { count: total, top: list };
  } catch (err) {
    console.error("[deploy-watcher] countAndTopErrors:", err);
    return { count: 0, top: [] };
  }
}

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

/**
 * Run the deploy watcher for a single deployment. Never throws.
 */
export async function runDeployWatcher(
  args: RunDeployWatcherArgs
): Promise<RunDeployWatcherResult> {
  const emptyResult = (summary: string): RunDeployWatcherResult => ({
    ok: false,
    summary,
    runId: null,
    rolledBack: false,
    incidentIssueNumber: null,
  });

  if (
    !args ||
    typeof args.repositoryId !== "string" ||
    !args.repositoryId ||
    typeof args.deployId !== "string" ||
    !args.deployId ||
    typeof args.commitSha !== "string" ||
    !args.commitSha
  ) {
    return emptyResult("invalid args: missing repositoryId/deployId/commitSha");
  }

  const trigger = args.triggerBy ? "manual" : "scheduled";

  const run = await startAgentRun({
    repositoryId: args.repositoryId,
    kind: "deploy_watcher",
    trigger,
    triggerRef: args.deployId,
  });
  if (!run) {
    return emptyResult("could not open agent_runs row");
  }

  let finalSummary = "not started";
  let rolledBack = false;
  let incidentIssueNumber: number | null = null;

  await executeAgentRun(run.id, async (ctx: AgentExecutorContext) => {
    await ctx.appendLog(
      `[deploy-watcher] starting watch for deploy ${args.deployId} @ ${args.commitSha.slice(0, 7)} (trigger=${trigger})`
    );

    const repo = await resolveRepoContext(args.repositoryId);
    if (!repo) {
      finalSummary = "repo lookup failed";
      await ctx.appendLog("[deploy-watcher] repo lookup failed; aborting");
      return { ok: false, summary: finalSummary };
    }

    const repoSlug = `${repo.ownerUsername}/${repo.repoName}`;
    const watchStart = new Date();

    await ctx.appendLog(
      `[deploy-watcher] calling crontech.watchDeployment for ${repoSlug}`
    );
    const watchResult = await watchDeployment({
      repo: repoSlug,
      deployId: args.deployId,
      maxWaitMs: DEPLOY_WATCHER_WINDOW_MS,
      pollIntervalMs: DEPLOY_WATCHER_POLL_MS,
    });
    await ctx.recordCost(0, 0, DEPLOY_WATCHER_COST_CENTS);

    if (watchResult.offline) {
      finalSummary = buildDeployWatcherSummary({
        offline: true,
        rolledBack: false,
        reason: "",
        incidentIssueNumber: null,
        watchedForMs: 0,
        errorSignalCount: 0,
      });
      await ctx.appendLog(`[deploy-watcher] ${finalSummary}`);
      return { ok: true, summary: finalSummary };
    }

    const { count: errorSignalCount, top: topErrors } = await countAndTopErrors(
      args.repositoryId,
      args.commitSha,
      watchStart
    );
    await ctx.appendLog(
      `[deploy-watcher] watch complete: finalStatus=${watchResult.finalStatus}, errorSignals=${errorSignalCount}, watchedForMs=${watchResult.watchedForMs}`
    );

    const decision = shouldRollback({
      watchResult,
      errorSignalCount,
      threshold: DEPLOY_WATCHER_ERROR_THRESHOLD,
    });

    if (!decision.rollback) {
      finalSummary = buildDeployWatcherSummary({
        offline: false,
        rolledBack: false,
        reason: decision.reason,
        incidentIssueNumber: null,
        watchedForMs: watchResult.watchedForMs,
        errorSignalCount,
      });
      await ctx.appendLog(`[deploy-watcher] ${decision.reason}`);
      return { ok: true, summary: finalSummary };
    }

    await ctx.appendLog(
      `[deploy-watcher] ROLLBACK TRIGGERED: ${decision.reason}`
    );

    const rollbackOk = await rollbackDeployment({
      repo: repoSlug,
      deployId: args.deployId,
    });
    rolledBack = rollbackOk;
    if (!rollbackOk) {
      await ctx.appendLog(
        `[deploy-watcher] crontech rollback failed; opening incident anyway`
      );
    }

    // Open a P0 incident issue.
    const authorId = await resolveWatcherAuthorId(repo.ownerId);
    if (!authorId) {
      finalSummary = `rollback ${rollbackOk ? "ok" : "failed"}; no author for incident`;
      await ctx.appendLog(`[deploy-watcher] ${finalSummary}`);
      return { ok: false, summary: finalSummary };
    }

    const body = renderIncidentIssueBody({
      commitSha: args.commitSha,
      ownerUsername: repo.ownerUsername,
      repoName: repo.repoName,
      deployId: args.deployId,
      reason: decision.reason,
      topErrors,
    });

    try {
      const [inserted] = await db
        .insert(issues)
        .values({
          repositoryId: repo.repoId,
          authorId,
          title: `P0: Regression in ${args.commitSha.slice(0, 7)}`,
          body,
        })
        .returning();
      incidentIssueNumber = inserted?.number ?? null;
    } catch (err) {
      await ctx.appendLog(
        `[deploy-watcher] incident issue insert failed: ${(err as Error).message}`
      );
    }

    finalSummary = buildDeployWatcherSummary({
      offline: false,
      rolledBack,
      reason: decision.reason,
      incidentIssueNumber,
      watchedForMs: watchResult.watchedForMs,
      errorSignalCount,
    });
    await ctx.appendLog(`[deploy-watcher] ${finalSummary}`);
    return { ok: rolledBack, summary: finalSummary };
  });

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

export const __internal = {
  DEPLOY_WATCHER_COST_CENTS,
  DEPLOY_WATCHER_ERROR_THRESHOLD,
  DEPLOY_WATCHER_WINDOW_MS,
  DEPLOY_WATCHER_POLL_MS,
  resolveRepoContext,
  resolveWatcherAuthorId,
  countAndTopErrors,
};