import type { Kysely } from "kysely";
import { logError, logInfo } from "@/lib/logger";
import {
  closeClickUpTask,
  createClickUpTask,
  createClickUpTaskComment,
} from "@/lib/clickup/client";
import { redactSensitive } from "@/internal/kevo/kevo.service";
import { GuruRepositoryFromDb, type TGuruRepository } from "./guru.repository";
import type { GuruTicket } from "@/internal/datastore/guru.types";

/**
 * Ticket lifecycle beyond the agent: concierge sign-off ("no longer an
 * issue") and the stale sweep (auto-close after N inactive days). Both keep
 * the three records in step — local ticket, ClickUp task, Viewpoint log —
 * with ClickUp/Viewpoint best-effort: a connector outage never blocks the
 * local close, it just lands in the audit metadata.
 */

export const STALE_DAYS = 7;

/** Compact Viewpoint closed-log write (CLOSED, 4xx fallback to OPEN). */
const writeViewpointLog = async (
  repo: TGuruRepository,
  ticket: GuruTicket,
  comment: string,
): Promise<void> => {
  if (!ticket.member_ref) return;
  try {
    const { ViewpointMember } = await import("@karma/viewpoint-sdk/member");
    const vp = new ViewpointMember();
    const payload = {
      accountID: ticket.member_ref,
      subject: `Karma Subito AI Guru — ${ticket.category ?? "support"} (${ticket.reference})`,
      comment: redactSensitive(comment),
    };
    try {
      await vp.createAuditLog({ ...payload, status: "CLOSED" });
      await repo.insertAudit({
        ticket_id: ticket.id,
        action: "viewpoint.logged",
        actor_email: ticket.concierge_email,
        member_ref: ticket.member_ref,
        success: true,
        metadata: { log_status: "CLOSED", via: "lifecycle" },
      });
    } catch (err) {
      const status = (err as { status?: number }).status;
      if (typeof status !== "number" || status < 400 || status >= 500)
        throw err;
      await vp.createAuditLog({ ...payload, status: "OPEN" });
      await repo.insertAudit({
        ticket_id: ticket.id,
        action: "viewpoint.logged",
        actor_email: ticket.concierge_email,
        member_ref: ticket.member_ref,
        success: true,
        metadata: {
          log_status: "OPEN",
          fallback: "CLOSED rejected by Viewpoint",
          via: "lifecycle",
        },
      });
    }
  } catch (err) {
    logError(`[Guru] Viewpoint log failed for ${ticket.reference}: ${err}`);
    await repo.insertAudit({
      ticket_id: ticket.id,
      action: "viewpoint.log_failed",
      actor_email: ticket.concierge_email,
      member_ref: ticket.member_ref,
      success: false,
      metadata: { via: "lifecycle" },
    });
  }
};

/**
 * Ensure the ticket has its ClickUp task (meeting notes §4: created as soon
 * as a case is substantiated — e.g. on first screenshot — not only post-call).
 * Returns the task id, or null when GURU_CLICKUP_LIST_ID is unset.
 */
export const ensureClickUpTaskForTicket = async (
  repo: TGuruRepository,
  ticket: GuruTicket,
  actorEmail: string,
): Promise<string | null> => {
  if (ticket.clickup_task_id) return ticket.clickup_task_id;
  const listId = process.env.GURU_CLICKUP_LIST_ID;
  if (!listId) return null;
  const consoleBase = process.env.CONSOLE_BASE_URL || "http://localhost:3002";
  const task = await createClickUpTask({
    listId,
    name: `[${ticket.reference}] ${ticket.category ?? "support case"}${
      ticket.member_ref ? ` — member ${ticket.member_ref}` : ""
    }`,
    markdown_description: [
      ticket.summary ?? "Concierge support case.",
      "",
      `**Console ticket:** ${consoleBase}/admin/guru/tickets/${ticket.reference}`,
      `**Concierge:** ${ticket.concierge_email}`,
      ...(ticket.member_ref ? [`**Member:** ${ticket.member_ref}`] : []),
    ].join("\n"),
    tags: ["guru"],
  });
  await repo.updateTicket(ticket.id, {
    clickup_task_id: task.id,
    clickup_task_url: task.url,
  });
  await repo.insertAudit({
    ticket_id: ticket.id,
    action: "clickup.created",
    actor_email: actorEmail,
    member_ref: ticket.member_ref,
    clickup_task_id: task.id,
    success: true,
  });
  return task.id;
};

/** Shared close: local status + audit, then ClickUp + Viewpoint best-effort. */
const closeEverywhere = async (
  repo: TGuruRepository,
  ticket: GuruTicket,
  opts: {
    resolution: "CLOSED_BY_CONCIERGE" | "AUTO_CLOSED_INACTIVE";
    actorEmail: string;
    note: string;
  },
): Promise<void> => {
  await repo.updateTicket(ticket.id, {
    status: "RESOLVED",
    resolution: opts.resolution,
    resolved_at: new Date(),
  });
  await repo.insertAudit({
    ticket_id: ticket.id,
    action:
      opts.resolution === "CLOSED_BY_CONCIERGE"
        ? "ticket.closed"
        : "ticket.auto_closed",
    actor_email: opts.actorEmail,
    member_ref: ticket.member_ref,
    clickup_task_id: ticket.clickup_task_id,
    success: true,
    metadata: { note: opts.note },
  });

  if (ticket.clickup_task_id) {
    const listId = process.env.GURU_CLICKUP_LIST_ID;
    try {
      await createClickUpTaskComment(ticket.clickup_task_id, opts.note);
      if (listId) await closeClickUpTask(ticket.clickup_task_id, listId);
    } catch (err) {
      logError(
        `[Guru] ClickUp close failed for ${ticket.reference}: ${err}`,
      );
      await repo.insertAudit({
        ticket_id: ticket.id,
        action: "clickup.close_failed",
        actor_email: opts.actorEmail,
        clickup_task_id: ticket.clickup_task_id,
        success: false,
      });
    }
  }

  await writeViewpointLog(repo, ticket, `${opts.note}\nTicket: ${ticket.reference}`);
};

/** Concierge sign-off. Caller has already verified ownership. */
export const closeTicketByConcierge = async (
  repo: TGuruRepository,
  ticket: GuruTicket,
  actorEmail: string,
): Promise<void> => {
  await closeEverywhere(repo, ticket, {
    resolution: "CLOSED_BY_CONCIERGE",
    actorEmail,
    note: `Case closed by the concierge (${actorEmail}) — no longer an issue.`,
  });
};

/**
 * Auto-close OPEN tickets with no activity for STALE_DAYS. Runs on an
 * hourly timer in cmd/services.ts.
 * ponytail: no distributed lock — a second core instance could double-run
 * the sweep; closes are idempotent-ish (second pass finds nothing OPEN),
 * worst case a duplicate ClickUp comment. Add a redis lock if core ever
 * runs multi-instance.
 */
export const sweepStaleTickets = async (
  pool: Kysely<unknown>,
  days = STALE_DAYS,
): Promise<number> => {
  const repo = GuruRepositoryFromDb(pool);
  const stale = await repo.listStaleOpenTickets(days);
  for (const ticket of stale) {
    try {
      await closeEverywhere(repo, ticket, {
        resolution: "AUTO_CLOSED_INACTIVE",
        actorEmail: "system",
        note: `This case was inactive for ${days} days and was closed automatically. Reopening the chat in Console 2 will reopen it.`,
      });
      logInfo(`[Guru] auto-closed stale ticket ${ticket.reference}`);
    } catch (err) {
      logError(`[Guru] stale sweep failed on ${ticket.reference}: ${err}`);
    }
  }
  return stale.length;
};
