import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
import { z } from 'zod';
import type { AuthRepository } from '../auth/auth-repository.js';
import { authenticateAccessToken } from '../auth/authenticate.js';
import type { AccessProfile } from '../auth/rbac-repository.js';
import type { ManagementActor } from '../auth/user-management-repository.js';
import {
  StoreRoomError,
  type StoreRoomRepository
} from '../stores/store-room-repository.js';

const idSchema = z.object({ id: z.string().regex(/^[1-9]\d{0,19}$/) });
const storeIdSchema = z.object({ storeId: z.string().regex(/^[1-9]\d{0,19}$/) });
const coordinate = z.number().finite();
const hoursSchema = z.array(z.object({
  weekday: z.number().int().min(1).max(7),
  openMinute: z.number().int().min(0).max(1439),
  closeMinute: z.number().int().min(0).max(1439),
  isClosed: z.boolean().default(false)
})).max(7).refine((items) => new Set(items.map((item) => item.weekday)).size === items.length);
const storeSchema = z.object({
  name: z.string().trim().min(1).max(128),
  address: z.string().trim().max(255).default(''),
  city: z.string().trim().max(64).default(''),
  district: z.string().trim().max(64).default(''),
  longitude: coordinate.min(-180).max(180).nullable().optional(),
  latitude: coordinate.min(-90).max(90).nullable().optional(),
  contactPhone: z.string().trim().max(32).default(''),
  timezone: z.string().trim().min(1).max(64).default('Asia/Shanghai'),
  businessStatus: z.enum(['OPEN', 'CLOSED', 'SUSPENDED']).default('OPEN'),
  wifiSsid: z.string().trim().max(128).default(''),
  wifiPassword: z.string().max(255).default(''),
  notificationUrl: z.union([z.string().url(), z.literal('')]).default(''),
  sortOrder: z.number().int().min(-100000).max(100000).default(0),
  businessHours: hoursSchema.default([])
});
const roomSchema = z.object({
  storeId: z.string().regex(/^[1-9]\d{0,19}$/),
  categoryName: z.string().trim().min(1).max(128),
  name: z.string().trim().min(1).max(128),
  roomNo: z.string().trim().min(1).max(64),
  capacity: z.number().int().min(1).max(100),
  basePriceCents: z.number().int().min(0).max(10000000),
  weekdayPriceCents: z.number().int().min(0).max(10000000),
  holidayPriceCents: z.number().int().min(0).max(10000000),
  overnightPriceCents: z.number().int().min(0).max(10000000),
  fullDayPriceCents: z.number().int().min(0).max(10000000).default(0),
  minimumSpendCents: z.number().int().min(0).max(10000000).default(0),
  depositCents: z.number().int().min(0).max(10000000),
  minimumMinutes: z.number().int().min(15).max(1440),
  maxAdvanceStartMinutes: z.number().int().min(0).max(1440),
  maxAdvanceDays: z.number().int().min(0).max(365),
  configurationStatus: z.enum(['ENABLED', 'DISABLED']),
  operationalStatus: z.enum([
    'AVAILABLE', 'MAINTENANCE', 'RESERVED', 'IN_USE', 'CLEANING_REQUIRED'
  ]),
  tags: z.array(z.string().trim().min(1).max(32)).max(20).default([]),
  images: z.array(z.string().url()).max(20).default([]),
  sortOrder: z.number().int().min(-100000).max(100000).default(0)
});
const disabledPeriodSchema = z.object({
  storeId: z.string().regex(/^[1-9]\d{0,19}$/),
  startsAt: z.coerce.date(),
  endsAt: z.coerce.date(),
  reason: z.string().trim().max(255).default('')
}).refine((value) => value.endsAt > value.startsAt);

export interface StoreRoomRouteOptions {
  repository: Pick<StoreRoomRepository,
    'listStores' | 'createStore' | 'updateStore' | 'archiveStore' | 'listRooms'
    | 'createRoom' | 'updateRoom' | 'archiveRoom' | 'addDisabledPeriod'>;
  authRepository: Pick<AuthRepository, 'validateSession'>;
  accessControl: { getAccessProfile(tenantId: string, userId: string): Promise<AccessProfile> };
  jwtSecret: string;
}

export async function registerStoreRoomRoutes(app: FastifyInstance, options: StoreRoomRouteOptions) {
  app.get('/admin-api/stores', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    if (!actor) return;
    return { code: 0, data: await options.repository.listStores(actor), traceId: request.traceId };
  });
  app.post('/admin-api/stores', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    const body = storeSchema.safeParse(request.body);
    if (!actor || !body.success) return actor ? invalid(reply, request.traceId) : undefined;
    return mutate(reply, request.traceId, async () => reply.status(201).send({
      code: 0, data: await options.repository.createStore(actor, body.data),
      traceId: request.traceId
    }));
  });
  app.put('/admin-api/stores/:id', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    const params = idSchema.safeParse(request.params);
    const body = storeSchema.safeParse(request.body);
    if (!actor || !params.success || !body.success) {
      return actor ? invalid(reply, request.traceId) : undefined;
    }
    return mutate(reply, request.traceId, async () => ({
      code: 0, data: await options.repository.updateStore(actor, params.data.id, body.data),
      traceId: request.traceId
    }));
  });
  app.delete('/admin-api/stores/:id', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    const params = idSchema.safeParse(request.params);
    if (!actor || !params.success) return actor ? invalid(reply, request.traceId) : undefined;
    return mutate(reply, request.traceId, async () => ({
      code: 0, data: await options.repository.archiveStore(actor, params.data.id),
      traceId: request.traceId
    }));
  });
  app.get('/admin-api/stores/:storeId/rooms', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    const params = storeIdSchema.safeParse(request.params);
    if (!actor || !params.success) return actor ? invalid(reply, request.traceId) : undefined;
    return mutate(reply, request.traceId, async () => ({
      code: 0, data: await options.repository.listRooms(actor, params.data.storeId),
      traceId: request.traceId
    }));
  });
  app.post('/admin-api/rooms', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    const body = roomSchema.safeParse(request.body);
    if (!actor || !body.success) return actor ? invalid(reply, request.traceId) : undefined;
    return mutate(reply, request.traceId, async () => reply.status(201).send({
      code: 0, data: await options.repository.createRoom(actor, body.data),
      traceId: request.traceId
    }));
  });
  app.put('/admin-api/rooms/:id', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    const params = idSchema.safeParse(request.params);
    const body = roomSchema.safeParse(request.body);
    if (!actor || !params.success || !body.success) {
      return actor ? invalid(reply, request.traceId) : undefined;
    }
    return mutate(reply, request.traceId, async () => ({
      code: 0, data: await options.repository.updateRoom(actor, params.data.id, body.data),
      traceId: request.traceId
    }));
  });
  app.delete('/admin-api/rooms/:id', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    const params = idSchema.safeParse(request.params);
    const query = storeIdSchema.safeParse(request.query);
    if (!actor || !params.success || !query.success) {
      return actor ? invalid(reply, request.traceId) : undefined;
    }
    return mutate(reply, request.traceId, async () => ({
      code: 0,
      data: await options.repository.archiveRoom(actor, params.data.id, query.data.storeId),
      traceId: request.traceId
    }));
  });
  app.post('/admin-api/rooms/:id/disabled-periods', async (request, reply) => {
    const actor = await requireOperator(request, reply, options);
    const params = idSchema.safeParse(request.params);
    const body = disabledPeriodSchema.safeParse(request.body);
    if (!actor || !params.success || !body.success) {
      return actor ? invalid(reply, request.traceId) : undefined;
    }
    return mutate(reply, request.traceId, async () => reply.status(201).send({
      code: 0,
      data: await options.repository.addDisabledPeriod(actor, params.data.id, body.data),
      traceId: request.traceId
    }));
  });
}

async function requireOperator(
  request: FastifyRequest, reply: FastifyReply, options: StoreRoomRouteOptions
): Promise<ManagementActor | null> {
  const auth = await authenticateAccessToken(
    request.headers.authorization, options.authRepository, options.jwtSecret
  );
  if (!auth) {
    reply.status(401).send({ code: 'AUTH_SESSION_INVALID', message: 'Authentication required.',
      traceId: request.traceId });
    return null;
  }
  const access = await options.accessControl.getAccessProfile(
    auth.session.tenantId, auth.session.user.id
  );
  if (!access.capabilities.some((code) =>
    code === 'store.operation.read' || code === 'store.operation.write' || code === 'tenant.manage'
  ) && !access.roles.includes('PLATFORM_ADMIN')) {
    reply.status(403).send({ code: 'STORE_OPERATION_FORBIDDEN',
      message: 'Store operation permission is required.', traceId: request.traceId });
    return null;
  }
  return {
    tenantId: auth.session.tenantId, userId: auth.session.user.id, access,
    traceId: request.traceId, ip: request.ip, userAgent: request.headers['user-agent'] ?? ''
  };
}

async function mutate(reply: FastifyReply, traceId: string, work: () => Promise<unknown>) {
  try {
    return await work();
  } catch (error) {
    if (!(error instanceof StoreRoomError)) throw error;
    const forbidden = error.code.endsWith('_FORBIDDEN');
    return reply.status(forbidden ? 403 : 404).send({
      code: error.code, message: 'The store or room operation is not allowed.', traceId
    });
  }
}

function invalid(reply: FastifyReply, traceId: string) {
  return reply.status(400).send({
    code: 'INVALID_STORE_ROOM_REQUEST', message: 'The store or room request is invalid.', traceId
  });
}