import { router, publicProcedure, protectedProcedure } from "../_core/trpc.ts";
import { z } from "zod";
import {
  getActivityFeed,
  getPlayerActivity,
  getActivityByType,
  getHighValueWins,
  getActivityStats,
  recordGameWin,
  recordAchievement,
  recordTournamentWin,
  recordMilestone,
} from "../services/activityFeedService.ts";

export const activityFeedRouter = router({
  // Get global activity feed
  getFeed: publicProcedure
    .input(z.object({ limit: z.number().default(50) }))
    .query(async ({ input }) => {
      try {
        const activities = await getActivityFeed(input.limit);
        return activities;
      } catch (error) {
        console.error("[ACTIVITY] Error fetching feed:", error);
        return [];
      }
    }),

  // Get player's activity history
  getPlayerActivity: publicProcedure
    .input(z.object({ playerId: z.number(), limit: z.number().default(20) }))
    .query(async ({ input }) => {
      try {
        const activities = await getPlayerActivity(input.playerId, input.limit);
        return activities;
      } catch (error) {
        console.error("[ACTIVITY] Error fetching player activity:", error);
        return [];
      }
    }),

  // Get activities by type (wins, achievements, tournaments, milestones)
  getByType: publicProcedure
    .input(
      z.object({
        type: z.enum(["win", "achievement", "tournament", "milestone"]),
        limit: z.number().default(50),
      })
    )
    .query(async ({ input }) => {
      try {
        const activities = await getActivityByType(input.type, input.limit);
        return activities;
      } catch (error) {
        console.error("[ACTIVITY] Error fetching activities by type:", error);
        return [];
      }
    }),

  // Get high-value wins (for FOMO)
  getHighValueWins: publicProcedure
    .input(z.object({ minAmount: z.number().default(1000), limit: z.number().default(20) }))
    .query(async ({ input }) => {
      try {
        const wins = await getHighValueWins(input.minAmount, input.limit);
        return wins;
      } catch (error) {
        console.error("[ACTIVITY] Error fetching high-value wins:", error);
        return [];
      }
    }),

  // Get activity statistics
  getStats: publicProcedure.query(async () => {
    try {
      const stats = await getActivityStats();
      return stats;
    } catch (error) {
      console.error("[ACTIVITY] Error fetching stats:", error);
      return {
        totalActivities: 0,
        totalWins: 0,
        totalAchievements: 0,
        totalTournaments: 0,
        totalMilestones: 0,
        totalWinAmount: 0,
      };
    }
  }),

  // Record a game win (internal use)
  recordWin: protectedProcedure
    .input(
      z.object({
        gameId: z.string(),
        gameName: z.string(),
        winAmount: z.number(),
        multiplier: z.number().default(1),
      })
    )
    .mutation(async ({ input, ctx }) => {
      try {
        if (!ctx.user) throw new Error("User not authenticated");
        const activity = await recordGameWin(
          ctx.user.id,
          ctx.user.name || "Anonymous",
          ctx.user.avatarUrl,
          input.gameId,
          input.gameName,
          input.winAmount,
          input.multiplier
        );
        return { success: true, activity };
      } catch (error) {
        console.error("[ACTIVITY] Error recording win:", error);
        return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
      }
    }),

  // Record an achievement (internal use)
  recordAchievement: protectedProcedure
    .input(
      z.object({
        achievementId: z.string(),
        achievementName: z.string(),
        achievementIcon: z.string(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      try {
        if (!ctx.user) throw new Error("User not authenticated");
        const activity = await recordAchievement(
          ctx.user.id,
          ctx.user.name || "Anonymous",
          ctx.user.avatarUrl,
          input.achievementId,
          input.achievementName,
          input.achievementIcon
        );
        return { success: true, activity };
      } catch (error) {
        console.error("[ACTIVITY] Error recording achievement:", error);
        return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
      }
    }),

  // Record a tournament win (internal use)
  recordTournamentWin: protectedProcedure
    .input(
      z.object({
        tournamentId: z.string(),
        tournamentName: z.string(),
        placement: z.number(),
        prizeAmount: z.number(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      try {
        if (!ctx.user) throw new Error("User not authenticated");
        const activity = await recordTournamentWin(
          ctx.user.id,
          ctx.user.name || "Anonymous",
          ctx.user.avatarUrl,
          input.tournamentId,
          input.tournamentName,
          input.placement,
          input.prizeAmount
        );
        return { success: true, activity };
      } catch (error) {
        console.error("[ACTIVITY] Error recording tournament win:", error);
        return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
      }
    }),

  // Record a milestone (internal use)
  recordMilestone: protectedProcedure
    .input(
      z.object({
        milestoneName: z.string(),
        milestoneIcon: z.string(),
        description: z.string(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      try {
        if (!ctx.user) throw new Error("User not authenticated");
        const activity = await recordMilestone(
          ctx.user.id,
          ctx.user.name || "Anonymous",
          ctx.user.avatarUrl,
          input.milestoneName,
          input.milestoneIcon,
          input.description
        );
        return { success: true, activity };
      } catch (error) {
        console.error("[ACTIVITY] Error recording milestone:", error);
        return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
      }
    }),
});