// ABOUTME: REST API routes for meeting data access
// ABOUTME: Provides listing and detail endpoints for racing meetings

import { Router, Request, Response } from 'express';
import { PrismaClient } from '@prisma/client';
import logger from '../utils/logger';

export function createMeetingsRouter(prisma: PrismaClient): Router {
  const router = Router();

  /**
   * GET /api/meetings
   * Query params: date (YYYY-MM-DD), country, category (T/H/G)
   * Returns: List of meetings with race counts
   */
  router.get('/', async (req: Request, res: Response) => {
    try {
      const { date, country, category } = req.query;

      // Build where clause
      const where: Record<string, unknown> = {};

      if (date) {
        const dateStr = date as string;
        const parsedDate = new Date(dateStr);
        if (isNaN(parsedDate.getTime())) {
          return res.status(400).json({ error: 'Invalid date parameter. Use YYYY-MM-DD format.' });
        }
        where.date = parsedDate;
      }

      if (country) {
        where.country = (country as string).toUpperCase();
      }

      if (category) {
        const cat = (category as string).toUpperCase();
        if (!['T', 'H', 'G'].includes(cat)) {
          return res.status(400).json({ error: 'Invalid category parameter. Must be T, H, or G.' });
        }
        where.category = cat;
      }

      logger.debug({ filters: where }, 'Fetching meetings');

      const meetings = await prisma.meeting.findMany({
        where,
        include: {
          _count: { select: { races: true } },
        },
        orderBy: [{ date: 'desc' }, { name: 'asc' }],
      });

      const data = meetings.map((m) => ({
        id: m.id,
        name: m.name,
        date: m.date,
        country: m.country,
        state: m.state,
        category: m.category,
        categoryName: m.categoryName,
        trackCondition: m.trackCondition,
        weather: m.weather,
        raceCount: m._count.races,
      }));

      logger.debug({ count: data.length }, 'Meetings fetched successfully');

      return res.json({
        data,
        meta: {
          total: data.length,
          limit: data.length,
          offset: 0,
          hasMore: false,
        },
      });
    } catch (error) {
      logger.error({ error }, 'Failed to fetch meetings');
      return res.status(500).json({
        error: error instanceof Error ? error.message : 'Unknown error',
      });
    }
  });

  /**
   * GET /api/meetings/:id
   * Returns: Meeting detail with embedded races
   */
  router.get('/:id', async (req: Request, res: Response) => {
    try {
      const id = req.params.id as string;

      logger.debug({ meetingId: id }, 'Fetching meeting by ID');

      const meeting = await prisma.meeting.findUnique({
        where: { id },
        include: {
          races: {
            orderBy: { raceNumber: 'asc' },
          },
        },
      });

      if (!meeting) {
        return res.status(404).json({ error: 'Meeting not found' });
      }

      return res.json({ data: meeting });
    } catch (error) {
      logger.error({ error, meetingId: req.params.id }, 'Failed to fetch meeting');
      return res.status(500).json({
        error: error instanceof Error ? error.message : 'Unknown error',
      });
    }
  });

  return router;
}