import { Router, Request, Response } from 'express';
import { z } from 'zod';
import { Role, StudentRequestStatus, StudentRequestType } from '@prisma/client';
import { asyncHandler } from '../../middleware/asyncHandler';
import { authenticate } from '../../middleware/authenticate';
import { authorize } from '../../middleware/authorize';
import { requirePermission } from '../../middleware/requirePermission';
import { propertyContext } from '../../middleware/propertyContext';
import { requireFeature } from '../../middleware/requireFeature';
import { getPagination, getSearch } from '../../lib/pagination';
import { ForbiddenError } from '../../lib/errors';
import * as svc from './requests.service';
import { issuePass, publicPass } from '../gate/gate.service';
import { decide as decideLeave } from '../leave/leave.service';
import * as grievance from './grievance.service';
import { db } from '../../lib/prisma';

/**
 * /api/requests — students raise and see their own; MANAGE_STUDENTS sees
 * and answers the queue.
 */
export const requestRouter = Router();
requestRouter.use(authenticate);

const dateish = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'date must be YYYY-MM-DD');
const createSchema = z.object({
  type: z.nativeEnum(StudentRequestType),
  subject: z.string().trim().min(3).max(120),
  body: z.string().trim().min(3).max(2000),
  fromDate: dateish.optional(),
  toDate: dateish.optional(),
  // Sprint 0 (TEPL): a complaint without the employee's name. Additive.
  anonymous: z.boolean().optional(),
  // Sprint 2 (TEPL): a sub-category from the type's list.
  category: z.string().trim().max(40).optional(),
});
const replySchema = z.object({ body: z.string().trim().min(1).max(2000) });
const statusSchema = z.object({
  status: z.nativeEnum(StudentRequestStatus),
  // Sprint 5: approving a LEAVE may issue a gate pass in the same call. Additive — old clients send status alone.
  issuePass: z.boolean().optional(),
  destination: z.string().trim().max(120).optional(),
});

const viewerOf = (req: Request) => ({ userId: req.user!.sub, role: req.user!.role, perms: req.user!.perms });
const isStudent = (req: Request) => req.user!.role === Role.STUDENT;
/** Staff never see who raised an anonymous request. */
const shown = <T extends Parameters<typeof svc.forStaff>[0]>(req: Request, r: T): T => (isStudent(req) ? r : svc.forStaff(r));
// Sprint 6
const slaSchema = z.object({ slas: z.array(z.object({ type: z.nativeEnum(StudentRequestType), hours: z.coerce.number().int().min(0).max(24 * 90) })).max(20) });
const vendorSchema = z.object({
  name: z.string().trim().min(2).max(80),
  trade: z.string().trim().max(60).optional(),
  phone: z.string().trim().max(20).optional(),
  note: z.string().trim().max(300).optional(),
});
const vendorPatchSchema = vendorSchema.partial().extend({ trade: z.string().trim().max(60).nullable().optional(), phone: z.string().trim().max(20).nullable().optional(), note: z.string().trim().max(300).nullable().optional(), isArchived: z.boolean().optional() });
const patchSchema = z
  .object({
    vendorId: z.string().uuid().nullable().optional(),
    dueBy: z.string().datetime().nullable().optional(),
    cost: z.coerce.number().int().min(0).max(10_000_000).nullable().optional(),
  })
  .refine((v) => Object.keys(v).length > 0, 'Nothing to update');

requestRouter.post(
  '/',
  authorize(Role.STUDENT),
  asyncHandler(async (req: Request, res: Response) =>
    res.status(201).json({ request: await svc.createRequest(req.user!.sub, createSchema.parse(req.body)) }),
  ),
);

requestRouter.get(
  '/',
  asyncHandler(async (req: Request, res: Response) => {
    const status =
      typeof req.query.status === 'string' && req.query.status in StudentRequestStatus
        ? (req.query.status as StudentRequestStatus)
        : undefined;
    const type =
      typeof req.query.type === 'string' && req.query.type in StudentRequestType
        ? (req.query.type as StudentRequestType)
        : undefined;
    // ACTIVE/CLOSED are not stored statuses but the two views both sides
    // actually use, so they are asked of the database rather than of a page.
    const openOnly = req.query.status === 'ACTIVE';
    const closedOnly = req.query.status === 'CLOSED';
    const breachedOnly = req.query.status === 'BREACHED';
    const pagination = getPagination(req.query);
    const q = getSearch(req.query);

    // A student's list is scoped by their account. The same filters apply
    // within it — they narrow, they cannot widen past the scope.
    // Sprint 0 (TEPL): ?assignee=me | none | <user id>, for the queue only.
    const assigneeQ = typeof req.query.assignee === 'string' ? req.query.assignee : undefined;
    const assigneeId = assigneeQ === 'me' ? req.user!.sub : assigneeQ === 'none' || (assigneeQ && z.string().uuid().safeParse(assigneeQ).success) ? assigneeQ : undefined;
    const filters = {
      status,
      type,
      q,
      openOnly,
      closedOnly,
      breachedOnly,
      ...(req.user!.role === Role.STUDENT ? { mineForUserId: req.user!.sub } : { assigneeId }),
      ...(typeof req.query.category === 'string' && /^[A-Z_]{2,40}$/.test(req.query.category) ? { category: req.query.category } : {}),
      escalatedOnly: req.query.status === 'ESCALATED',
    };
    if (req.user!.role !== Role.STUDENT) svc.assertCanManage(req.user!.perms);

    const result = await svc.listRequests(filters, pagination);
    if (isStudent(req)) return res.json(pagination ? result : { requests: result });
    if (Array.isArray(result)) return res.json({ requests: svc.forStaffList(result) });
    res.json({ ...result, items: svc.forStaffList(result.items) });
  }),
);

requestRouter.get(
  '/summary',
  asyncHandler(async (req: Request, res: Response) => {
    if (req.user!.role === Role.STUDENT) {
      return res.json({ summary: await svc.requestSummary(req.user!.sub) });
    }
    svc.assertCanManage(req.user!.perms);
    res.json({ summary: await svc.requestSummary() });
  }),
);

// ── Grievance desk (Sprint 2, TEPL) — literal paths before /:id ──────────
requestRouter.get('/categories', requireFeature('grievanceDesk'), asyncHandler(async (_req, res) => res.json({ categories: grievance.REQUEST_CATEGORIES })));
requestRouter.get(
  '/grievance-summary',
  requireFeature('grievanceDesk'),
  requirePermission('MANAGE_STUDENTS'),
  propertyContext,
  asyncHandler(async (req: Request, res: Response) => {
    const days = z.coerce.number().int().min(1).max(366).default(30).parse(req.query.days ?? 30);
    res.json({ summary: await grievance.grievanceSummary(days, req.propertyId) });
  }),
);

// ── Assignment (Sprint 0, TEPL) — literal paths before /:id ──────────────
/** The staff member's own task list: what is handed to them. */
requestRouter.get(
  '/assigned',
  requireFeature('assignments'),
  asyncHandler(async (req: Request, res: Response) => {
    if (isStudent(req)) throw new ForbiddenError('Only staff have tasks');
    // Paged when asked (Sprint L3); otherwise the first 200 as before.
    const pagination = getPagination(req.query);
    if (pagination) {
      const page = await svc.pageAssigned(req.user!.sub, req.query.status !== 'ALL', pagination);
      res.json({ ...page, items: svc.forStaffList(page.items) });
      return;
    }
    const rows = await svc.listAssigned(req.user!.sub, req.query.status !== 'ALL');
    res.json({ requests: svc.forStaffList(rows) });
  }),
);
requestRouter.get(
  '/assignable-staff',
  requireFeature('assignments'),
  requirePermission('MANAGE_STUDENTS'),
  asyncHandler(async (_req: Request, res: Response) => res.json({ staff: await svc.assignableStaff() })),
);

// ── SLAs and vendors (Sprint 6) — literal paths before /:id ──────────────
requestRouter.get('/slas', requirePermission('MANAGE_STUDENTS'), asyncHandler(async (_req, res) => res.json({ slas: await svc.listSlas() })));
requestRouter.put(
  '/slas',
  requirePermission('MANAGE_STUDENTS'),
  asyncHandler(async (req: Request, res: Response) => res.json({ slas: await svc.setSlas(slaSchema.parse(req.body).slas) })),
);
requestRouter.get(
  '/vendors',
  requirePermission('MANAGE_STUDENTS'),
  asyncHandler(async (req: Request, res: Response) => res.json({ vendors: await svc.listVendors(req.query.all === 'true') })),
);
requestRouter.post(
  '/vendors',
  propertyContext,
  requirePermission('MANAGE_STUDENTS'),
  asyncHandler(async (req: Request, res: Response) => res.status(201).json({ vendor: await svc.createVendor(vendorSchema.parse(req.body), req.propertyId) })),
);
requestRouter.patch(
  '/vendors/:id',
  requirePermission('MANAGE_STUDENTS'),
  asyncHandler(async (req: Request, res: Response) => res.json({ vendor: await svc.updateVendor(req.params.id, vendorPatchSchema.parse(req.body)) })),
);

requestRouter.get(
  '/:id',
  asyncHandler(async (req: Request, res: Response) => {
    // Staff: the queue (MANAGE_STUDENTS) or the person it is handed to — loadForViewer decides.
    res.json({ request: shown(req, await svc.getRequest(req.params.id, viewerOf(req))) });
  }),
);

requestRouter.post(
  '/:id/replies',
  asyncHandler(async (req: Request, res: Response) => {
    const { body } = replySchema.parse(req.body);
    res.status(201).json({ request: shown(req, await svc.reply(req.params.id, viewerOf(req), body)) });
  }),
);

requestRouter.patch(
  '/:id/status',
  asyncHandler(async (req: Request, res: Response) => {
    const { status, issuePass: wantPass, destination } = statusSchema.parse(req.body);
    if (isStudent(req)) throw new ForbiddenError('Requires permission: MANAGE_STUDENTS');
    // Sprint 0 (TEPL): the person a task is handed to may start and finish it — nothing more.
    const manages = req.user!.perms.includes('MANAGE_STUDENTS');
    if (!manages) {
      await svc.assertCanHandle(req.params.id, { userId: req.user!.sub, perms: req.user!.perms });
      if (status !== StudentRequestStatus.IN_PROGRESS && status !== StudentRequestStatus.RESOLVED) {
        throw new ForbiddenError('You can mark a task in progress or done');
      }
    }
    // Sprint 1 (TEPL): a leave under the policy is decided step by step (hostel,
    // then plant), so approving or declining it here goes through that path.
    if (status === StudentRequestStatus.APPROVED || status === StudentRequestStatus.REJECTED) {
      const policy = await db.studentRequest.findFirst({ where: { id: req.params.id, leaveTypeId: { not: null } }, select: { id: true } });
      if (policy) {
        await decideLeave(policy.id, { userId: req.user!.sub, role: req.user!.role, perms: req.user!.perms }, status === StudentRequestStatus.APPROVED ? 'APPROVE' : 'REJECT');
        // Never the raw row: it carries the QR token's hash.
        const row = await db.gatePass.findFirst({ where: { requestId: policy.id } });
        const pass = row ? publicPass(row) : null;
        return res.json({ request: svc.forStaff((await svc.getRequest(policy.id, { userId: req.user!.sub, role: req.user!.role, perms: req.user!.perms }))!), pass });
      }
    }
    const request = (await svc.setStatus(req.params.id, status, req.user!.sub))!;
    let pass = null;
    if (manages && wantPass && status === StudentRequestStatus.APPROVED && request.type === 'LEAVE') {
      pass = (await issuePass(request.id, { destination }, req.user!.sub)).pass;
    }
    res.json({ request: svc.forStaff(request), pass });
  }),
);

/** Sprint 0 (TEPL): hand a request to a member of staff, or take it back. */
requestRouter.patch(
  '/:id/assign',
  requireFeature('assignments'),
  requirePermission('MANAGE_STUDENTS'),
  asyncHandler(async (req: Request, res: Response) => {
    const { assigneeId } = z.object({ assigneeId: z.string().uuid().nullable() }).parse(req.body);
    res.json({ request: svc.forStaff(await svc.assignRequest(req.params.id, assigneeId, req.user!.sub)) });
  }),
);

/** Sprint 6: vendor, due time and cost. The cost books as an expense when the request closes. */
requestRouter.patch(
  '/:id',
  requirePermission('MANAGE_STUDENTS'),
  asyncHandler(async (req: Request, res: Response) => {
    const input = patchSchema.parse(req.body);
    const request = await svc.patchRequest(
      req.params.id,
      { ...input, dueBy: input.dueBy === undefined ? undefined : input.dueBy === null ? null : new Date(input.dueBy) },
      req.user!.sub,
    );
    res.json({ request: svc.forStaff(request) });
  }),
);

/** Issue (or re-read) the gate pass for an approved leave. MANAGE_STUDENTS or MANAGE_GATE. */
requestRouter.post(
  '/:id/pass',
  asyncHandler(async (req: Request, res: Response) => {
    const perms = req.user!.perms ?? [];
    if (!perms.includes('MANAGE_STUDENTS') && !perms.includes('MANAGE_GATE')) throw new ForbiddenError('Requires permission: MANAGE_STUDENTS or MANAGE_GATE');
    const input = z.object({ destination: z.string().trim().max(120).optional() }).parse(req.body ?? {});
    res.status(201).json(await issuePass(req.params.id, input, req.user!.sub));
  }),
);

/** Sprint 2 (TEPL): the employee rates a closed request, 1–5. */
requestRouter.post(
  '/:id/rating',
  authorize(Role.STUDENT),
  asyncHandler(async (req: Request, res: Response) => {
    const { rating, comment } = z.object({ rating: z.number().int().min(1).max(5), comment: z.string().trim().max(500).nullable().optional() }).parse(req.body);
    res.json(await grievance.rateRequest(req.user!.sub, req.params.id, rating, comment ?? null));
  }),
);

requestRouter.delete(
  '/:id',
  authorize(Role.STUDENT),
  asyncHandler(async (req: Request, res: Response) => {
    res.json({ request: await svc.cancelRequest(req.params.id, req.user!.sub) });
  }),
);
