"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var previews_exports = {};
__export(previews_exports, {
  getPreview: () => getPreview,
  listPreviews: () => listPreviews,
  previewLogsWs: () => previewLogsWs,
  stopPreviewRoute: () => stopPreviewRoute
});
module.exports = __toCommonJS(previews_exports);
var import_db = require("../../lib/db");
var import_response = require("../../lib/response");
var import_errors = require("../../lib/errors");
var import_deploy = require("../../services/deploy");
function requireAuth(ctr) {
  const auth = ctr.getAuth?.();
  if (!auth?.success) return null;
  return auth.user;
}
async function listPreviews(ctr) {
  const user = requireAuth(ctr);
  if (!user) return (0, import_response.makeResponse)({ ctr, content: { code: 401, message: import_errors.ERROR_MESSAGES.UNAUTHORIZED.message } });
  const previews = await import_db.prisma.preview.findMany({
    where: { repoConfig: { userId: user.id } },
    include: { repoConfig: { select: { repoOwner: true, repoName: true } } },
    orderBy: { updatedAt: "desc" }
  });
  return (0, import_response.makeResponse)({
    ctr,
    content: {
      code: 200,
      data: previews.map((p) => ({
        id: p.id,
        prNumber: p.prNumber,
        prTitle: p.prTitle,
        commitSha: p.commitSha,
        status: p.status,
        instanceIp: p.instanceIp,
        port: p.port,
        createdAt: p.createdAt,
        updatedAt: p.updatedAt,
        lastActivityAt: p.lastActivityAt,
        repoOwner: p.repoConfig.repoOwner,
        repoName: p.repoConfig.repoName
      }))
    }
  });
}
async function getPreview(ctr) {
  const user = requireAuth(ctr);
  if (!user) return (0, import_response.makeResponse)({ ctr, content: { code: 401, message: import_errors.ERROR_MESSAGES.UNAUTHORIZED.message } });
  const id = parseInt(ctr.params.get("id") || "0", 10);
  const preview = await import_db.prisma.preview.findFirst({
    where: { id, repoConfig: { userId: user.id } },
    include: {
      repoConfig: { select: { repoOwner: true, repoName: true } },
      jobs: { orderBy: { createdAt: "desc" }, take: 10 }
    }
  });
  if (!preview) return (0, import_response.makeResponse)({ ctr, content: { code: 404, message: import_errors.ERROR_MESSAGES.NOT_FOUND.message } });
  return (0, import_response.makeResponse)({
    ctr,
    content: {
      code: 200,
      data: {
        id: preview.id,
        prNumber: preview.prNumber,
        prTitle: preview.prTitle,
        commitSha: preview.commitSha,
        status: preview.status,
        instanceIp: preview.instanceIp,
        port: preview.port,
        logs: preview.logs,
        createdAt: preview.createdAt,
        updatedAt: preview.updatedAt,
        stoppedAt: preview.stoppedAt,
        lastActivityAt: preview.lastActivityAt,
        repoOwner: preview.repoConfig.repoOwner,
        repoName: preview.repoConfig.repoName,
        jobs: preview.jobs.map((j) => ({
          id: j.id,
          type: j.type,
          status: j.status,
          createdAt: j.createdAt,
          startedAt: j.startedAt,
          finishedAt: j.finishedAt,
          error: j.error
        }))
      }
    }
  });
}
async function stopPreviewRoute(ctr) {
  const user = requireAuth(ctr);
  if (!user) return (0, import_response.makeResponse)({ ctr, content: { code: 401, message: import_errors.ERROR_MESSAGES.UNAUTHORIZED.message } });
  const id = parseInt(ctr.params.get("id") || "0", 10);
  const preview = await import_db.prisma.preview.findFirst({
    where: { id, repoConfig: { userId: user.id } }
  });
  if (!preview) return (0, import_response.makeResponse)({ ctr, content: { code: 404, message: import_errors.ERROR_MESSAGES.NOT_FOUND.message } });
  if (preview.status === "STOPPED") return (0, import_response.makeResponse)({ ctr, content: { code: 400, message: "Already stopped" } });
  await import_db.prisma.job.create({
    data: { previewId: id, type: "STOP", status: "PENDING", payload: { reason: "Manual stop via UI" } }
  });
  return (0, import_response.makeResponse)({ ctr, content: { code: 200, message: "Stop job enqueued" } });
}
async function previewLogsWs(ctr) {
  const auth = ctr.getAuth?.();
  if (!auth?.success) {
    ctr.close(1008, "Unauthorized");
    return;
  }
  const id = parseInt(ctr.params.get("id") || "0", 10);
  const preview = await import_db.prisma.preview.findFirst({
    where: { id, repoConfig: { userId: auth.user.id } }
  });
  if (!preview) {
    ctr.close(1008, "Not found");
    return;
  }
  await ctr.print(JSON.stringify({ type: "init", logs: preview.logs }));
  const unsub = (0, import_deploy.subscribeToLogs)(id, (text) => {
    try {
      ctr.print(JSON.stringify({ type: "append", text }));
    } catch {
    }
  });
  ctr.$abort(unsub);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  getPreview,
  listPreviews,
  previewLogsWs,
  stopPreviewRoute
});
//# sourceMappingURL=previews.js.map