import { timingSafeEqual } from 'node:crypto';
import express, { Router, type Request, type Response } from 'express';
import { z } from 'zod';
import { BlogPostStatus } from '@prisma/client';
import { asyncHandler } from '../../middleware/asyncHandler';
import { authenticate } from '../../middleware/authenticate';
import { rateLimit } from '../../middleware/rateLimit';
import { env } from '../../config/env';
import { ServiceUnavailableError, UnauthorizedError } from '../../lib/errors';
import * as invites from '../crm/crm-invites.service';
import { blogActorOf, requireBlogAccess, requireSuperAdmin } from './blog-access';
import * as posts from './blog-posts.service';
import * as media from './blog-media.service';
import * as builds from './blog-builds.service';
import * as editors from './blog-editors.service';
import { DOCX_MAX_BYTES, importDocx } from './blog-docx.service';
import { postFieldsSchema } from './blog-rules';

/**
 * The website blog CMS (docs/blog-cms-plan.md).
 *
 *   GET  /api/blog-cms/feed               public, X-Blog-Feed-Token: the website build
 *   /api/blog-cms/invites/:token          public: the set-password page behind an invite
 *   posts, media, import, builds          SUPER_ADMIN + CONTENT_EDITOR
 *   /api/blog-cms/editors                 SUPER_ADMIN only
 *
 * A CONTENT_EDITOR can reach nothing else (authenticate's fence), and no
 * hostel role ever gets past requireBlogAccess.
 */
export const blogCmsRouter = Router();

const idParam = z.object({ id: z.string().uuid('Invalid id') });
const pageQuery = (max: number, fallback: number) =>
  z.object({
    page: z.coerce.number().int().min(1).default(1),
    limit: z.coerce.number().int().min(1).max(max).default(fallback),
    q: z.string().trim().max(100).optional().transform((v) => v || undefined),
  });

// ── Public: the website build's feed ──────────────────────────────────────

const feedLimiter = rateLimit({ windowMs: 10 * 60 * 1000, max: 120, name: 'blog-feed' });

function feedTokenOk(given: string | undefined): boolean {
  const expected = env.BLOG_FEED_TOKEN;
  if (!expected || !given) return false;
  const a = Buffer.from(given);
  const b = Buffer.from(expected);
  return a.length === b.length && timingSafeEqual(a, b);
}

blogCmsRouter.get(
  '/feed',
  feedLimiter,
  asyncHandler(async (req: Request, res: Response) => {
    if (!env.BLOG_FEED_TOKEN) throw new ServiceUnavailableError('The blog feed is not set up on this server (BLOG_FEED_TOKEN).', 'FEED_NOT_CONFIGURED');
    if (!feedTokenOk(req.header('x-blog-feed-token'))) throw new UnauthorizedError('Wrong or missing feed token.', 'BAD_FEED_TOKEN');
    res.set('Cache-Control', 'no-store');
    res.json(await posts.feed());
  }),
);

// ── Public: the set-password page behind an editor's invite link ──────────

const inviteLimiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 30, name: 'blog-invite' });
const acceptSchema = z.object({
  password: z.string().min(8, 'Password must be at least 8 characters').max(200, 'Password must be at most 200 characters'),
});

blogCmsRouter.get(
  '/invites/:token',
  inviteLimiter,
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ invite: await invites.lookupInvite(String(req.params.token)) });
  }),
);
blogCmsRouter.post(
  '/invites/:token/accept',
  inviteLimiter,
  asyncHandler(async (req: Request, res: Response) => {
    const { password } = acceptSchema.parse(req.body);
    res.json(await invites.acceptInvite(String(req.params.token), password));
  }),
);

// ── Everything else: the super admin and content editors ──────────────────

blogCmsRouter.use(authenticate, requireBlogAccess);

blogCmsRouter.get(
  '/posts',
  asyncHandler(async (req: Request, res: Response) => {
    const q = pageQuery(100, 25)
      .extend({ status: z.nativeEnum(BlogPostStatus).optional() })
      .parse(req.query);
    res.json(await posts.listPosts(q));
  }),
);

blogCmsRouter.get(
  '/posts/check-slug',
  asyncHandler(async (req: Request, res: Response) => {
    const { slug, excludeId } = z.object({ slug: z.string().trim().max(100), excludeId: z.string().uuid().optional() }).parse(req.query);
    res.json(await posts.checkSlug(slug, excludeId));
  }),
);

blogCmsRouter.post(
  '/posts',
  asyncHandler(async (req: Request, res: Response) => {
    const fields = postFieldsSchema.parse(req.body);
    res.status(201).json({ post: await posts.createPost(fields, blogActorOf(res)) });
  }),
);

blogCmsRouter.get(
  '/posts/:id',
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ post: await posts.getPost(idParam.parse(req.params).id) });
  }),
);

blogCmsRouter.patch(
  '/posts/:id',
  asyncHandler(async (req: Request, res: Response) => {
    const fields = postFieldsSchema.parse(req.body);
    res.json({ post: await posts.updatePost(idParam.parse(req.params).id, fields, blogActorOf(res)) });
  }),
);

blogCmsRouter.post(
  '/posts/:id/review',
  asyncHandler(async (req: Request, res: Response) => {
    const { review } = z.object({ review: z.boolean() }).parse(req.body);
    res.json({ post: await posts.setReview(idParam.parse(req.params).id, review, blogActorOf(res)) });
  }),
);

blogCmsRouter.post(
  '/posts/:id/publish',
  asyncHandler(async (req: Request, res: Response) => {
    const { publishAt } = z.object({ publishAt: z.coerce.date({ errorMap: () => ({ message: 'Choose a valid date and time' }) }).nullable().optional() }).parse(req.body ?? {});
    res.json({ post: await posts.publishPost(idParam.parse(req.params).id, publishAt ?? null, blogActorOf(res)) });
  }),
);

blogCmsRouter.post(
  '/posts/:id/unpublish',
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ post: await posts.unpublishPost(idParam.parse(req.params).id, blogActorOf(res)) });
  }),
);

blogCmsRouter.delete(
  '/posts/:id',
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ post: await posts.archivePost(idParam.parse(req.params).id, blogActorOf(res)) });
  }),
);

blogCmsRouter.post(
  '/posts/:id/restore',
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ post: await posts.restorePost(idParam.parse(req.params).id, blogActorOf(res)) });
  }),
);

blogCmsRouter.get(
  '/posts/:id/revisions',
  asyncHandler(async (req: Request, res: Response) => {
    const { page, limit } = pageQuery(50, 20).parse(req.query);
    res.json(await posts.listRevisions(idParam.parse(req.params).id, { page, limit }));
  }),
);

blogCmsRouter.post(
  '/posts/:id/revisions/:revisionId/restore',
  asyncHandler(async (req: Request, res: Response) => {
    const { id, revisionId } = z.object({ id: z.string().uuid(), revisionId: z.string().uuid('Invalid id') }).parse(req.params);
    res.json({ post: await posts.restoreRevision(id, revisionId, blogActorOf(res)) });
  }),
);

// ── Images ────────────────────────────────────────────────────────────────

blogCmsRouter.get(
  '/media',
  asyncHandler(async (req: Request, res: Response) => {
    res.json(await media.listMedia(pageQuery(100, 40).parse(req.query)));
  }),
);

// The image itself is the request body (as /api/uploads/direct does it):
// read raw, capped at the door, and its type taken from its bytes.
blogCmsRouter.post(
  '/media',
  express.raw({ type: () => true, limit: media.MEDIA_MAX_BYTES + 1024 }),
  asyncHandler(async (req: Request, res: Response) => {
    const q = z.object({ filename: z.string().trim().max(200).default('image'), alt: z.string().trim().max(200).optional() }).parse(req.query);
    const body = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
    const m = await media.createMedia({ body, filename: q.filename, alt: q.alt ?? null, userId: blogActorOf(res).id });
    res.status(201).json({ media: await media.presentMedia(m) });
  }),
);

blogCmsRouter.patch(
  '/media/:id',
  asyncHandler(async (req: Request, res: Response) => {
    const { alt } = z.object({ alt: z.string().trim().max(200, 'At most 200 characters').nullable() }).parse(req.body);
    res.json({ media: await media.updateMediaAlt(idParam.parse(req.params).id, alt) });
  }),
);

blogCmsRouter.delete(
  '/media/:id',
  asyncHandler(async (req: Request, res: Response) => {
    res.json(await media.deleteMedia(idParam.parse(req.params).id));
  }),
);

// ── Word import ───────────────────────────────────────────────────────────

blogCmsRouter.post(
  '/import/docx',
  express.raw({ type: () => true, limit: DOCX_MAX_BYTES + 1024 }),
  asyncHandler(async (req: Request, res: Response) => {
    const { filename } = z.object({ filename: z.string().trim().max(200).default('document.docx') }).parse(req.query);
    const body = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
    res.status(201).json(await importDocx({ body, filename }, blogActorOf(res)));
  }),
);

// ── Website builds ────────────────────────────────────────────────────────

blogCmsRouter.get(
  '/builds/latest',
  asyncHandler(async (_req: Request, res: Response) => {
    res.json(await builds.latestBuild());
  }),
);

blogCmsRouter.post(
  '/builds',
  asyncHandler(async (_req: Request, res: Response) => {
    res.status(201).json(await builds.retryBuild(blogActorOf(res).id));
  }),
);

// ── Writers (super admin) ─────────────────────────────────────────────────

const text = (label: string, min: number, max: number) =>
  z
    .string()
    .trim()
    .min(min, `${label} must be at least ${min} characters`)
    .max(max, `${label} must be at most ${max} characters`)
    .refine((v) => !/[\u0000-\u001f\u007f]/.test(v), `${label} contains invalid characters`);
const email = z.string().trim().toLowerCase().email('Enter a valid email address').max(160, 'Email must be at most 160 characters');
const phone = z.string().trim().max(20, 'Phone must be at most 20 characters').regex(/^[0-9+()\-\s]*$/, 'Phone can only have digits, spaces, +, - and brackets');

const editorsRouter = Router();
editorsRouter.use(requireSuperAdmin);

editorsRouter.get(
  '/',
  asyncHandler(async (req: Request, res: Response) => {
    const f = z.object({ q: z.string().trim().max(100).optional(), status: z.enum(['INVITED', 'ACTIVE', 'DEACTIVATED']).optional() }).parse(req.query);
    res.json(await editors.listEditors(f));
  }),
);
editorsRouter.post(
  '/',
  asyncHandler(async (req: Request, res: Response) => {
    const input = z.object({ name: text('Name', 2, 120), email, phone: phone.optional() }).parse(req.body);
    res.status(201).json(await editors.createEditor(input, blogActorOf(res)));
  }),
);
editorsRouter.patch(
  '/:id',
  asyncHandler(async (req: Request, res: Response) => {
    const input = z
      .object({ name: text('Name', 2, 120), email, phone })
      .partial()
      .refine((v) => Object.keys(v).length > 0, 'Nothing to update')
      .parse(req.body);
    res.json({ editor: await editors.updateEditor(idParam.parse(req.params).id, input) });
  }),
);
editorsRouter.post(
  '/:id/send-link',
  asyncHandler(async (req: Request, res: Response) => {
    res.json(await editors.sendPasswordLink(idParam.parse(req.params).id, blogActorOf(res)));
  }),
);
editorsRouter.post(
  '/:id/deactivate',
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ editor: await editors.deactivateEditor(idParam.parse(req.params).id) });
  }),
);
editorsRouter.post(
  '/:id/reactivate',
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ editor: await editors.reactivateEditor(idParam.parse(req.params).id) });
  }),
);
editorsRouter.post(
  '/:id/sign-out',
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ editor: await editors.signOutEverywhere(idParam.parse(req.params).id) });
  }),
);

blogCmsRouter.use('/editors', editorsRouter);
