import { StudentRequestStatus, TenantKind } from '@prisma/client';
import { db } from '../../lib/prisma';
import { getTenantIdOrThrow } from '../../lib/tenantContext';
import type { Permission } from '../../lib/permissions';
import type { FeatureKey } from '../../lib/tenant-features';
import type { Sheet } from '../../lib/xlsx';
import { tenantKindOf } from '../../middleware/requireFeature';

/**
 * The reports that can be downloaded as Excel or emailed on a timetable
 * (Sprint 0, TEPL). Each module adds its own here as it is built — shift
 * adherence, leave, grievances and the rest — and gets the download button
 * and the scheduler with it. Every report runs inside a tenant context, so
 * the scoped client keeps it to one hostel.
 */

export interface ReportContext {
  propertyId?: string;
  now: Date;
  /** India dates the download asked for (reports with `ranged`); otherwise each uses its own window. */
  range?: { from: string; to: string };
  /** Being emailed on a timetable, not looked at now. */
  scheduled?: boolean;
}

/** A headline number above the report on screen. */
export interface ReportHighlight {
  label: string;
  value: string | number;
}

export interface ReportDef {
  key: string;
  title: string;
  description: string;
  /** Needed to download it or schedule it. */
  permission: Permission;
  /** Other permissions that may run it too (Sprint 7: managing compliance includes reading it). */
  alsoAllowed?: Permission[];
  /** The module it belongs to; offered only where that is on. */
  feature?: FeatureKey;
  /** Takes a from/to range on download (Sprint 4 follow-up, TEPL); schedules keep the default window. */
  ranged?: boolean;
  /** The days a ranged report opens on, on screen: the last N, this week so far, or this month so far. */
  defaultDays?: number | 'week' | 'month';
  /** Headline numbers for the screen, worked out from what was built. */
  highlights?(sheets: Sheet[]): ReportHighlight[];
  build(ctx: ReportContext): Promise<Sheet[]>;
}

const REPORTS = new Map<string, ReportDef>();

export function registerReport(def: ReportDef) {
  REPORTS.set(def.key, def);
}

/** May someone holding these permissions run this report? */
export function mayRun(def: ReportDef, perms: Permission[]) {
  return perms.includes(def.permission) || !!def.alsoAllowed?.some((p) => perms.includes(p));
}

export function reportByKey(key: string): ReportDef | undefined {
  return REPORTS.get(key);
}

export function allReports(): ReportDef[] {
  return [...REPORTS.values()];
}

/** How the Reports page groups them, in this order. A report not listed goes under Other. */
export const REPORT_GROUPS: { name: string; keys: string[] }[] = [
  { name: 'People and rooms', keys: ['occupancy', 'residents', 'special-needs', 'room-register', 'store-stock'] },
  { name: 'Attendance and leave', keys: ['staff-attendance', 'shift-adherence', 'leave-register'] },
  { name: 'Gate and outings', keys: ['outings', 'curfew-breaches', 'visitors', 'bus-trips'] },
  { name: 'Mess and laundry', keys: ['canteen-consumption', 'meal-ratings', 'laundry'] },
  { name: 'Housekeeping and energy', keys: ['cleaning-frequency', 'energy-consumption'] },
  { name: 'Complaints and feedback', keys: ['requests', 'grievances', 'feedback', 'discipline-register'] },
  { name: 'Safety and compliance', keys: ['emergency-log', 'compliance-register', 'compliance-inspections', 'medical-access-log'] },
  { name: 'Leadership and events', keys: ['leadership', 'events'] },
];
export const groupOf = (key: string) => REPORT_GROUPS.find((g) => g.keys.includes(key))?.name ?? 'Other';

/** "Employee" in an employee hostel, "Resident" elsewhere — the column header word. */
async function personWord(): Promise<string> {
  return (await tenantKindOf(getTenantIdOrThrow())) === TenantKind.ENTERPRISE ? 'Employee' : 'Resident';
}

/** OCCUPIED → Occupied, IN_PROGRESS → In progress. */
const words = (s: string) => s.replace(/_/g, ' ').toLowerCase().replace(/^./, (c) => c.toUpperCase());

const roomOf = (bed: { label: string; room: { number: string } } | null | undefined) => (bed ? `${bed.room.number} / ${bed.label}` : '');

// ── Built-in reports ────────────────────────────────────────────────────────

registerReport({
  key: 'occupancy',
  title: 'Occupancy',
  description: 'Every room and bed, who is in it, and what is free.',
  permission: 'VIEW_OCCUPANCY',
  highlights(sheets) {
    const beds = sheets[1].rows;
    const count = (status: string) => beds.filter((b) => b[3] === status).length;
    return [
      { label: 'Rooms', value: sheets[0].rows.length },
      { label: 'Beds', value: beds.length },
      { label: 'Occupied', value: count('Occupied') },
      { label: 'Free', value: beds.length - count('Occupied') - count('Reserved') },
    ];
  },
  async build({ propertyId }) {
    const person = await personWord();
    const rooms = await db.room.findMany({
      where: { archivedAt: null, ...(propertyId ? { propertyId } : {}) },
      include: {
        property: { select: { name: true } },
        beds: { where: { archivedAt: null }, include: { student: { include: { user: { select: { name: true, phone: true } } } } } },
      },
      orderBy: [{ property: { name: 'asc' } }, { floor: 'asc' }, { number: 'asc' }],
      take: 5000,
    });
    const summary = rooms.map((r) => {
      const occupied = r.beds.filter((b) => b.status === 'OCCUPIED').length;
      const reserved = r.beds.filter((b) => b.status === 'RESERVED').length;
      return [r.property.name, r.number, r.floor ?? '', r.beds.length, occupied, reserved, r.beds.length - occupied - reserved];
    });
    const beds = rooms.flatMap((r) =>
      r.beds
        .slice()
        .sort((a, b) => a.label.localeCompare(b.label, 'en', { numeric: true }))
        .map((b) => [r.property.name, r.number, b.label, words(b.status), b.student?.user.name ?? '', b.student?.user.phone ?? '', b.student?.movedInAt ?? null]),
    );
    return [
      {
        name: 'Rooms',
        columns: [{ header: 'Property', width: 22 }, { header: 'Room' }, { header: 'Floor' }, { header: 'Beds' }, { header: 'Occupied' }, { header: 'Reserved' }, { header: 'Free' }],
        rows: summary,
      },
      {
        name: 'Beds',
        columns: [{ header: 'Property', width: 22 }, { header: 'Room' }, { header: 'Bed' }, { header: 'Status' }, { header: person, width: 26 }, { header: 'Phone', width: 14 }, { header: 'Moved in', width: 14 }],
        rows: beds,
      },
    ];
  },
});

registerReport({
  key: 'residents',
  title: 'People list',
  description: 'Everyone staying now, with room, phone and move-in date.',
  permission: 'MANAGE_STUDENTS',
  highlights: (sheets) => [{ label: 'Staying now', value: sheets[0].rows.length }],
  async build({ propertyId }) {
    const person = await personWord();
    const people = await db.studentProfile.findMany({
      where: { residencyStatus: 'ACTIVE', ...(propertyId ? { propertyId } : {}) },
      include: { user: { select: { name: true, phone: true, email: true, hasLogin: true } }, property: { select: { name: true } }, bed: { include: { room: { select: { number: true } } } } },
      orderBy: { user: { name: 'asc' } },
      take: 10000,
    });
    const employee = person === 'Employee';
    return [
      {
        name: employee ? 'Employees' : 'Residents',
        columns: [{ header: person, width: 26 }, { header: 'Phone', width: 14 }, { header: 'Email', width: 28 }, { header: 'Property', width: 22 }, { header: 'Room / bed', width: 12 }, { header: 'Moved in', width: 14 }, { header: 'Emergency contact', width: 24 }, { header: 'Emergency phone', width: 16 }, ...(employee ? [{ header: 'Parent', width: 24 }, { header: 'Parent phone', width: 16 }] : [])],
        rows: people.map((p) => [p.user.name, p.user.phone ?? '', p.user.hasLogin ? p.user.email : '', p.property?.name ?? '', roomOf(p.bed), p.movedInAt, p.guardianName ?? '', p.guardianPhone ?? '', ...(employee ? [p.parentName ?? '', p.parentPhone ?? ''] : [])]),
      },
    ];
  },
});

registerReport({
  key: 'requests',
  title: 'Open requests and complaints',
  description: 'Everything not yet closed, oldest first, with who has it and whether it is overdue.',
  permission: 'MANAGE_STUDENTS',
  highlights(sheets) {
    const rows = sheets[0].rows;
    return [
      { label: 'Open', value: rows.length },
      { label: 'Overdue', value: rows.filter((r) => r[8] === 'Yes').length },
      { label: 'With nobody', value: rows.filter((r) => !r[6]).length },
    ];
  },
  async build({ propertyId, now }) {
    const person = await personWord();
    const rows = await db.studentRequest.findMany({
      where: { status: { in: [StudentRequestStatus.OPEN, StudentRequestStatus.IN_PROGRESS] }, ...(propertyId ? { student: { propertyId } } : {}) },
      include: {
        student: { include: { user: { select: { name: true } }, bed: { include: { room: { select: { number: true } } } } } },
        assignee: { select: { name: true } },
        vendor: { select: { name: true } },
      },
      orderBy: { createdAt: 'asc' },
      take: 5000,
    });
    return [
      {
        name: 'Open',
        columns: [{ header: 'Raised', width: 18 }, { header: 'Type', width: 14 }, { header: 'Subject', width: 40 }, { header: person, width: 24 }, { header: 'Room / bed', width: 12 }, { header: 'Status', width: 12 }, { header: 'With', width: 22 }, { header: 'Due by', width: 18 }, { header: 'Overdue' }, { header: 'Age (days)' }],
        rows: rows.map((r) => [
          r.createdAt,
          words(r.type),
          r.subject,
          // Anonymous stays anonymous in every report.
          r.anonymous ? 'Anonymous' : r.student.user.name,
          r.anonymous ? '' : roomOf(r.student.bed),
          words(r.status),
          r.assignee?.name ?? r.vendor?.name ?? '',
          r.dueBy,
          r.dueBy && r.dueBy < now ? 'Yes' : '',
          Math.floor((now.getTime() - r.createdAt.getTime()) / 86_400_000),
        ]),
      },
    ];
  },
});
