import crypto from "node:crypto";
import { marked } from "marked";
import {
  StoreError,
  addCategory,
  createContentSnapshot,
  deleteArticle,
  discardDraft,
  generateSlug,
  getCategoryNames,
  getCategoryStats,
  getPublishStatus,
  listWorkingArticles,
  publishArticle,
  readWorkingArticle,
  removeCategory,
  renameCategory,
  safeSlug,
  saveUpload,
  unpublishArticle,
  writeArticle,
} from "./article-store";
import { buildSiteAtomic, tryAcquireSiteBuildLock, withSiteBuildLock } from "../../scripts/site-build.mjs";

const PASSWORD = process.env.CMS_PASSWORD || "admin";
const SECRET = process.env.CMS_SECRET || crypto.randomBytes(32).toString("hex");
const API_KEY = process.env.CMS_API_KEY || "";
const CAPTCHA_TTL = 5 * 60 * 1000;
const CAPTCHA_CHARS = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
const MAX_LOGIN_FAILURES = 5;
const LOGIN_FAILURE_WINDOW = 10 * 60 * 1000;
const LOGIN_BLOCK_DURATION = 10 * 60 * 1000;
const loginAttempts = new Map<string, { count: number; first: number; blockedUntil: number }>();
type BuildState = {
  status: "idle" | "building" | "success" | "error";
  ok: boolean | null;
  log: string;
  startedAt: string | null;
  finishedAt: string | null;
};
let buildState: BuildState = { status: "idle", ok: null, log: "", startedAt: null, finishedAt: null };

const json = (data: unknown, status = 200, headers?: HeadersInit) => Response.json(data, { status, headers });

const safeEqual = (leftValue: unknown, rightValue: unknown): boolean => {
  const left = Buffer.from(String(leftValue));
  const right = Buffer.from(String(rightValue));
  return left.length === right.length && crypto.timingSafeEqual(left, right);
};

const sessionToken = () => crypto.createHmac("sha256", SECRET).update("yinzhuang-cms-v1").digest("hex");

function cookies(request: Request): Record<string, string> {
  return Object.fromEntries((request.headers.get("cookie") || "").split(";").filter(Boolean).map((part) => {
    const index = part.indexOf("=");
    return [part.slice(0, index).trim(), decodeURIComponent(part.slice(index + 1).trim())];
  }));
}

function apiKeyValid(request: Request): boolean {
  if (!API_KEY) return false;
  const auth = request.headers.get("authorization")?.match(/^Bearer\s+(.+)$/i)?.[1];
  const key = auth || request.headers.get("x-api-key");
  return key ? safeEqual(key, API_KEY) : false;
}

const authed = (request: Request): boolean =>
  Boolean(cookies(request).cms_session && safeEqual(cookies(request).cms_session, sessionToken())) || apiKeyValid(request);

async function bodyOf(request: Request): Promise<Record<string, unknown>> {
  try { return await request.json(); } catch { return {}; }
}

function cookieHeader(request: Request, name: string, value: string, maxAge: number): string {
  const forwarded = request.headers.get("x-forwarded-proto");
  const secure = new URL(request.url).protocol === "https:" || forwarded === "https";
  return `${name}=${value}; HttpOnly; SameSite=Strict; Path=/; Max-Age=${maxAge}${secure ? "; Secure" : ""}`;
}

function loginBlockedFor(ip: string): number {
  const state = loginAttempts.get(ip);
  return state?.blockedUntil && state.blockedUntil > Date.now()
    ? Math.ceil((state.blockedUntil - Date.now()) / 1000)
    : 0;
}

function loginFailed(ip: string): void {
  const now = Date.now();
  let state = loginAttempts.get(ip);
  if (!state || now - state.first > LOGIN_FAILURE_WINDOW) {
    state = { count: 0, first: now, blockedUntil: 0 };
  }
  state.count += 1;
  if (state.count >= MAX_LOGIN_FAILURES) state.blockedUntil = now + LOGIN_BLOCK_DURATION;
  loginAttempts.set(ip, state);
}

function randomCaptcha(length = 4): string {
  let code = "";
  for (let index = 0; index < length; index += 1) {
    code += CAPTCHA_CHARS[crypto.randomInt(CAPTCHA_CHARS.length)];
  }
  return code;
}

function captchaMac(code: unknown, expiresAt: number): string {
  return crypto.createHmac("sha256", SECRET)
    .update(`${String(code).toUpperCase()}|${expiresAt}`)
    .digest("hex");
}

function captchaValid(request: Request, answer: unknown): boolean {
  const value = cookies(request).cms_captcha;
  if (!value || !answer) return false;
  const separator = value.lastIndexOf(".");
  const expiresAt = Number(value.slice(0, separator));
  const mac = value.slice(separator + 1);
  return Boolean(expiresAt && Date.now() <= expiresAt && safeEqual(mac, captchaMac(answer, expiresAt)));
}

function captchaSvg(code: string): string {
  const width = 132;
  const height = 46;
  const colors = ["#11897b", "#0e727c", "#16ae9c", "#243532"];
  const randomBetween = (min: number, max: number) => crypto.randomInt(min, max + 1);
  const pick = <T>(items: T[]): T => items[crypto.randomInt(items.length)];
  let content = `<rect width="${width}" height="${height}" fill="#e4efea"/>`;
  for (let index = 0; index < 4; index += 1) {
    content += `<line x1="${randomBetween(0, width)}" y1="${randomBetween(0, height)}" x2="${randomBetween(0, width)}" y2="${randomBetween(0, height)}" stroke="${pick(colors)}" stroke-width="1" opacity="0.45"/>`;
  }
  [...code].forEach((character, index) => {
    const x = 16 + index * 28 + randomBetween(-3, 3);
    const y = 31 + randomBetween(-4, 4);
    const rotation = randomBetween(-26, 26);
    content += `<text x="${x}" y="${y}" font-family="Georgia,serif" font-weight="700" font-size="${randomBetween(24, 30)}" fill="${pick(colors)}" transform="rotate(${rotation} ${x} ${y})">${character}</text>`;
  });
  for (let index = 0; index < 26; index += 1) {
    content += `<circle cx="${randomBetween(0, width)}" cy="${randomBetween(0, height)}" r="1" fill="${pick(colors)}" opacity="0.5"/>`;
  }
  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">${content}</svg>`;
}

function requireSlug(value: string | undefined): string {
  const slug = safeSlug(value);
  if (!slug) throw new StoreError("网址标识不合法");
  return slug;
}

async function startContentBuild(change: () => Promise<void>): Promise<boolean> {
  if (buildState.status === "building") return false;
  const releaseLock = await tryAcquireSiteBuildLock();
  if (!releaseLock) return false;
  buildState = { status: "building", ok: null, log: "", startedAt: new Date().toISOString(), finishedAt: null };
  void (async () => {
    const snapshot = await createContentSnapshot();
    try {
      await change();
      const log = await buildSiteAtomic();
      buildState = { status: "success", ok: true, log, startedAt: buildState.startedAt, finishedAt: new Date().toISOString() };
    } catch (error) {
      let rollbackMessage = "";
      try { await snapshot.restore(); } catch (rollbackError) {
        rollbackMessage = `\n内容回滚失败：${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`;
      }
      const message = error instanceof Error ? error.message : String(error);
      const log = typeof error === "object" && error && "log" in error ? String(error.log || "") : "";
      buildState = {
        status: "error",
        ok: false,
        log: `${log}${log ? "\n" : ""}${message}${rollbackMessage}`,
        startedAt: buildState.startedAt,
        finishedAt: new Date().toISOString(),
      };
    }
  })().finally(releaseLock).catch((error) => {
    buildState = {
      status: "error",
      ok: false,
      log: error instanceof Error ? error.message : String(error),
      startedAt: buildState.startedAt,
      finishedAt: new Date().toISOString(),
    };
  });
  return true;
}

async function startOrConflict(change: () => Promise<void>): Promise<Response> {
  if (!await startContentBuild(change)) {
    return json({ error: "网站正在部署或生成静态页面，本次操作未受理，请稍后重试" }, 409, { "Retry-After": "5" });
  }
  return json({ ok: true, status: "building" });
}

export async function handleCmsApi(request: Request, routeValue: string, clientAddress = "unknown"): Promise<Response> {
  const route = routeValue.replace(/^\/+|\/+$/g, "");
  const parts = route.split("/").filter(Boolean);
  const method = request.method.toUpperCase();

  try {
    if (route === "captcha" && method === "GET") {
      const code = randomCaptcha();
      const expiresAt = Date.now() + CAPTCHA_TTL;
      return new Response(captchaSvg(code), {
        headers: {
          "Cache-Control": "no-store",
          "Content-Type": "image/svg+xml; charset=utf-8",
          "Set-Cookie": cookieHeader(request, "cms_captcha", `${expiresAt}.${captchaMac(code, expiresAt)}`, CAPTCHA_TTL / 1000),
        },
      });
    }

    if (route === "session") {
      if (method === "GET") return json({ authed: authed(request) });
      if (method === "POST") {
        const blockedFor = loginBlockedFor(clientAddress);
        if (blockedFor) return json({ error: `尝试过于频繁，请 ${Math.ceil(blockedFor / 60)} 分钟后再试` }, 429);
        const body = await bodyOf(request);
        const clearCaptcha = cookieHeader(request, "cms_captcha", "", 0);
        if (!captchaValid(request, body.captcha)) {
          return json({ error: "验证码错误或已过期" }, 400, { "Set-Cookie": clearCaptcha });
        }
        if (!safeEqual(body.password || "", PASSWORD)) {
          loginFailed(clientAddress);
          return json({ error: "管理密码错误" }, 401, { "Set-Cookie": clearCaptcha });
        }
        loginAttempts.delete(clientAddress);
        const headers = new Headers();
        headers.append("Set-Cookie", clearCaptcha);
        headers.append("Set-Cookie", cookieHeader(request, "cms_session", sessionToken(), 86400));
        return json({ ok: true }, 200, headers);
      }
      if (method === "DELETE") return json({ ok: true }, 200, { "Set-Cookie": cookieHeader(request, "cms_session", "", 0) });
    }

    if (!authed(request)) throw new StoreError("请先登录文章后台", 401);

    if (route === "categories") {
      if (method === "GET") return json({ categories: await getCategoryNames(), stats: await getCategoryStats() });
      const body = await bodyOf(request);
      if (method === "POST") {
        return startOrConflict(async () => { await addCategory(body.name); });
      }
      if (method === "PATCH") {
        return startOrConflict(async () => { await renameCategory(body.current, body.name); });
      }
      if (method === "DELETE") {
        return startOrConflict(async () => { await removeCategory(body.name, body.replacement); });
      }
    }

    if (route === "build" && method === "GET") return json(buildState);

    if (route === "articles") {
      if (method === "GET") return json(await listWorkingArticles());
      if (method === "POST") {
        const body = await bodyOf(request);
        if (!String(body.title || "").trim()) throw new StoreError("请填写文章标题");
        if (!String(body.body || "").trim()) throw new StoreError("请填写文章正文");
        const slug = await generateSlug(body.category);
        const article = await withSiteBuildLock(() => writeArticle(slug, body, true));
        return json({ ok: true, slug, publishStatus: await getPublishStatus(article) }, 201);
      }
    }

    if (parts[0] === "articles" && parts[1]) {
      const slug = requireSlug(parts[1]);
      if (parts.length === 3 && parts[2] === "draft" && method === "DELETE") {
        return json({ ok: true, ...await withSiteBuildLock(() => discardDraft(slug)) });
      }
      if (parts.length === 3 && parts[2] === "publish" && method === "POST") {
        return startOrConflict(async () => { await publishArticle(slug); });
      }
      if (parts.length === 3 && parts[2] === "unpublish" && method === "POST") {
        return startOrConflict(async () => { await unpublishArticle(slug); });
      }
      if (parts.length === 2 && method === "GET") {
        const article = await readWorkingArticle(slug);
        return json({ ...article, publishStatus: await getPublishStatus(article) });
      }
      if (parts.length === 2 && method === "PUT") {
        const body = await bodyOf(request);
        if (!String(body.title || "").trim()) throw new StoreError("请填写文章标题");
        if (!String(body.body || "").trim()) throw new StoreError("请填写文章正文");
        const article = await withSiteBuildLock(() => writeArticle(slug, body));
        return json({ ok: true, slug, publishStatus: await getPublishStatus(article) });
      }
      if (parts.length === 2 && method === "DELETE") {
        return startOrConflict(async () => { await deleteArticle(slug); });
      }
    }

    if (route === "preview" && method === "POST") {
      const body = await bodyOf(request);
      return json({ html: await marked.parse(String(body.body || "")) });
    }

    if (route === "uploads" && method === "POST") {
      const body = await bodyOf(request);
      return json({ ok: true, url: await saveUpload(body.dataUrl) });
    }

    return json({ error: "接口不存在" }, 404);
  } catch (error) {
    if (error instanceof StoreError) return json({ error: error.message, ...error.details }, error.status);
    if ((error as NodeJS.ErrnoException).code === "ENOENT") return json({ error: "文章不存在" }, 404);
    console.error(error);
    return json({ error: error instanceof Error ? error.message : "服务器处理失败" }, 500);
  }
}
