import { z } from 'zod';
import { protectedProcedure, router } from "../_core/trpc.ts";
import { TRPCError } from '@trpc/server';
import { getActiveSeasonalEvent, getEventMultiplier, getActiveEvents, getEventName } from "../services/seasonalBonusMultiplier.ts";
import { getVariantsByEvent, getActiveVariants } from "../services/gameVariants.ts";

export const seasonalEventsAdminRouter = router({
  // Get current active event
  getActiveEvent: protectedProcedure.query(async ({ ctx }) => {
    if (ctx.user.role !== 'admin') {
      throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin only' });
    }

    const activeEvent = getActiveSeasonalEvent();
    if (!activeEvent) {
      return null;
    }

    return {
      eventId: activeEvent.eventId,
      name: getEventName(activeEvent.eventId),
      multiplier: activeEvent.multiplier,
    };
  }),

  // Get all active events with details
  getAllActiveEvents: protectedProcedure.query(async ({ ctx }) => {
    if (ctx.user.role !== 'admin') {
      throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin only' });
    }

    const activeEvents = getActiveEvents();
    return activeEvents.map((event) => ({
      eventId: event.eventId,
      name: getEventName(event.eventId),
      multiplier: event.multiplier,
      variants: getVariantsByEvent(event.eventId),
    }));
  }),

  // Get event multiplier
  getEventMultiplier: protectedProcedure
    .input(z.object({ eventId: z.string() }))
    .query(async ({ input, ctx }) => {
      if (ctx.user.role !== 'admin') {
        throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin only' });
      }

      return {
        eventId: input.eventId,
        name: getEventName(input.eventId),
        multiplier: getEventMultiplier(input.eventId),
      };
    }),

  // Get game variants for event
  getEventVariants: protectedProcedure
    .input(z.object({ eventId: z.string() }))
    .query(async ({ input, ctx }) => {
      if (ctx.user.role !== 'admin') {
        throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin only' });
      }

      const variants = getVariantsByEvent(input.eventId);
      return {
        eventId: input.eventId,
        eventName: getEventName(input.eventId),
        variants,
        totalVariants: variants.length,
      };
    }),

  // Get all active game variants
  getActiveVariants: protectedProcedure.query(async ({ ctx }) => {
    if (ctx.user.role !== 'admin') {
      throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin only' });
    }

    const variants = getActiveVariants();
    return {
      totalActive: variants.length,
      variants,
    };
  }),

  // Get seasonal events statistics
  getSeasonalStats: protectedProcedure.query(async ({ ctx }) => {
    if (ctx.user.role !== 'admin') {
      throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin only' });
    }

    const activeEvents = getActiveEvents();
    const activeVariants = getActiveVariants();

    return {
      activeEvents: activeEvents.length,
      activeVariants: activeVariants.length,
      events: activeEvents.map((event) => ({
        eventId: event.eventId,
        name: getEventName(event.eventId),
        multiplier: event.multiplier,
        variants: getVariantsByEvent(event.eventId).length,
      })),
      totalBonusMultiplier: activeEvents.reduce((sum, e) => sum + e.multiplier, 0),
    };
  }),

  // Log seasonal event activity
  logEventActivity: protectedProcedure
    .input(
      z.object({
        eventId: z.string(),
        action: z.enum(['view', 'participate', 'reward_claim', 'variant_play']),
        gameId: z.number().optional(),
        userId: z.number().optional(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      if (ctx.user.role !== 'admin') {
        throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin only' });
      }

      // In production, this would log to database
      console.log(`[Seasonal Event] ${input.action}: ${input.eventId}`, {
        gameId: input.gameId,
        userId: input.userId || ctx.user.id,
        timestamp: new Date().toISOString(),
      });

      return {
        success: true,
        message: `Activity logged for event: ${input.eventId}`,
      };
    }),

  // Get event configuration
  getEventConfig: protectedProcedure
    .input(z.object({ eventId: z.string() }))
    .query(async ({ input, ctx }) => {
      if (ctx.user.role !== 'admin') {
        throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin only' });
      }

      const multiplier = getEventMultiplier(input.eventId);
      const variants = getVariantsByEvent(input.eventId);

      return {
        eventId: input.eventId,
        name: getEventName(input.eventId),
        multiplier,
        variants: variants.map((v) => ({
          id: v.id,
          name: v.variantName,
          rtp: v.rtp,
          volatility: v.volatility,
          features: v.specialFeatures,
        })),
        config: {
          bonusMultiplier: multiplier,
          specialGamesCount: variants.length,
          rewardTiers: 3, // Placeholder
        },
      };
    }),
});