import type { FastifyInstance } from 'fastify';
import { config } from '../config.js';
import { intakeService, blacklistService } from '../services/intake.service.js';
import { requireAdminAuth } from '../middleware/auth.js';

export async function adminRoutes(app: FastifyInstance): Promise<void> {
  app.addHook('preHandler', requireAdminAuth);

  app.get('/api/intake/pending', async () => {
    return intakeService.list({ decision: 'pending', limit: 200 });
  });

  app.get('/api/intake/tickets', async () => {
    const items = intakeService.list({ decision: 'approved', limit: 200 });
    return items.filter((i) => i.decision === 'approved');
  });

  app.get('/api/intake/ignored', async () => {
    return intakeService.list({ decision: ['ignored', 'auto_ignored'], limit: 200 });
  });

  app.get('/api/intake/:id', async (request, reply) => {
    const { id } = request.params as { id: string };
    const item = intakeService.getById(id);
    if (!item) return reply.code(404).send({ error: 'not_found' });
    return item;
  });

  app.post('/api/intake/:id/approve', async (request, reply) => {
    const { id } = request.params as { id: string };
    const item = intakeService.approve(id);
    if (!item) return reply.code(409).send({ error: 'cannot_approve', message: 'Item not pending' });
    return item;
  });

  app.post('/api/intake/:id/ignore', async (request, reply) => {
    const { id } = request.params as { id: string };
    const item = intakeService.ignore(id);
    if (!item) return reply.code(409).send({ error: 'cannot_ignore', message: 'Item not pending' });
    return item;
  });

  app.post('/api/intake/:id/restore', async (request, reply) => {
    const { id } = request.params as { id: string };
    const item = intakeService.restore(id);
    if (!item) return reply.code(409).send({ error: 'cannot_restore' });
    return item;
  });

  app.post('/api/intake/:id/blacklist-sender', async (request, reply) => {
    const { id } = request.params as { id: string };
    const sender = blacklistService.ignoreSenderFromItem(id);
    if (!sender) return reply.code(400).send({ error: 'no_sender', message: 'No identifiable sender' });
    return sender;
  });

  app.get('/api/blacklist', async () => blacklistService.list(true));

  app.post('/api/blacklist', async (request, reply) => {
    const body = request.body as {
      sender_type: 'email' | 'monday_user';
      sender_key: string;
      sender_label?: string;
      reason?: string;
    };
    return blacklistService.addSender(body);
  });

  app.post('/api/blacklist/:id/reactivate', async (request) => {
    const { id } = request.params as { id: string };
    return blacklistService.reactivate(id);
  });

  app.post('/api/blacklist/:id/deactivate', async (request) => {
    const { id } = request.params as { id: string };
    return blacklistService.deactivate(id);
  });

  app.get('/api/sources/status', async () => ({
    gmail: {
      enabled: config.gmail.enabled(),
      configured: Boolean(config.gmail.clientId),
      pollIntervalMs: config.gmail.pollIntervalMs,
      searchQuery: config.gmail.searchQuery,
    },
    monday: {
      enabled: config.monday.enabled(),
      configured: Boolean(config.monday.apiToken),
      boardIds: config.monday.boardIds,
      pollIntervalMs: config.monday.pollIntervalMs,
    },
    extension: {
      enabled: true,
    },
    demo: {
      enabled: config.isDev,
    },
  }));
}