import { router, adminProcedure } from "../_core/trpc.ts";
import { z } from "zod";
import {
  AIEmployeeRole,
  TaskStatus,
  DutyReportStatus,
  createAITask,
  getAIEmployeeTasks,
  updateTaskStatus,
  generateLuckyAIReport,
  generateFraudAIReport,
  generateGameAIReport,
  generateSlotsAIReport,
  generateBingoAIReport,
  generatePokerAIReport,
  generateSportsAIReport,
  submitAIDutyReport,
  getDutyReportsForDate,
  approveDutyReport,
} from "../services/aiEmployeeSystem.ts";

export const aiEmployeeManagementRouter = router({
  // Create a new task for an AI employee
  createTask: adminProcedure
    .input(
      z.object({
        employeeRole: z.nativeEnum(AIEmployeeRole),
        title: z.string(),
        description: z.string(),
        priority: z.enum(["low", "medium", "high"]).default("medium"),
        dueDate: z.string().optional(),
        metadata: z.record(z.any()).optional(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      const task = await createAITask(
        input.employeeRole,
        input.title,
        input.description,
        input.priority,
        input.dueDate,
        ctx.user.id,
        input.metadata
      );

      return {
        success: true,
        task,
        message: `Task created for ${input.employeeRole}`,
      };
    }),

  // Get all tasks for an AI employee
  getTasks: adminProcedure
    .input(z.object({ employeeRole: z.nativeEnum(AIEmployeeRole) }))
    .query(async ({ input }) => {
      const tasks = await getAIEmployeeTasks(input.employeeRole);
      return tasks;
    }),

  // Update task status
  updateTaskStatus: adminProcedure
    .input(
      z.object({
        taskId: z.number(),
        status: z.nativeEnum(TaskStatus),
        metadata: z.record(z.any()).optional(),
      })
    )
    .mutation(async ({ input }) => {
      const task = await updateTaskStatus(input.taskId, input.status, input.metadata);

      return {
        success: !!task,
        task,
        message: task ? `Task status updated to ${input.status}` : "Task not found",
      };
    }),

  // Generate LuckyAI daily report
  generateLuckyAIReport: adminProcedure.query(async () => {
    const report = await generateLuckyAIReport();

    return {
      success: true,
      employeeRole: AIEmployeeRole.LUCKY_AI,
      report,
      generatedAt: new Date().toISOString(),
    };
  }),

  // Generate FraudAI daily report
  generateFraudAIReport: adminProcedure.query(async () => {
    const report = await generateFraudAIReport();

    return {
      success: true,
      employeeRole: AIEmployeeRole.FRAUD_AI,
      report,
      generatedAt: new Date().toISOString(),
    };
  }),

  // Generate GameAI daily report with new games
  generateGameAIReport: adminProcedure.query(async () => {
    const { report, games } = await generateGameAIReport();

    return {
      success: true,
      employeeRole: AIEmployeeRole.GAME_AI,
      report,
      games,
      gameCount: games.length,
      generatedAt: new Date().toISOString(),
    };
  }),

  // Generate SlotsAI daily report
  generateSlotsAIReport: adminProcedure.query(async () => {
    const report = await generateSlotsAIReport();

    return {
      success: true,
      employeeRole: AIEmployeeRole.SLOTS_AI,
      report,
      generatedAt: new Date().toISOString(),
    };
  }),

  // Generate BingoAI daily report
  generateBingoAIReport: adminProcedure.query(async () => {
    const report = await generateBingoAIReport();

    return {
      success: true,
      employeeRole: AIEmployeeRole.BINGO_AI,
      report,
      generatedAt: new Date().toISOString(),
    };
  }),

  // Generate PokerAI daily report
  generatePokerAIReport: adminProcedure.query(async () => {
    const report = await generatePokerAIReport();

    return {
      success: true,
      employeeRole: AIEmployeeRole.POKER_AI,
      report,
      generatedAt: new Date().toISOString(),
    };
  }),

  // Generate SportsAI daily report
  generateSportsAIReport: adminProcedure.query(async () => {
    const report = await generateSportsAIReport();

    return {
      success: true,
      employeeRole: AIEmployeeRole.SPORTS_AI,
      report,
      generatedAt: new Date().toISOString(),
    };
  }),

  // Submit duty report for an AI employee
  submitDutyReport: adminProcedure
    .input(
      z.object({
        employeeRole: z.nativeEnum(AIEmployeeRole),
        tasksCompleted: z.number(),
        recommendations: z.array(z.string()),
        summary: z.string(),
        metadata: z.record(z.any()).optional(),
      })
    )
    .mutation(async ({ input }) => {
      const report = await submitAIDutyReport(
        input.employeeRole,
        input.tasksCompleted,
        input.recommendations,
        input.summary,
        input.metadata
      );

      return {
        success: true,
        report,
        message: `Duty report submitted by ${input.employeeRole}`,
      };
    }),

  // Get all duty reports for a specific date
  getDutyReports: adminProcedure
    .input(z.object({ date: z.string() }))
    .query(async ({ input }) => {
      const reports = await getDutyReportsForDate(input.date);
      return reports;
    }),

  // Approve or deny duty report
  approveDutyReport: adminProcedure
    .input(
      z.object({
        reportId: z.number(),
        approved: z.boolean(),
        adminNotes: z.string().optional(),
      })
    )
    .mutation(async ({ input }) => {
      const report = await approveDutyReport(input.reportId, input.approved, input.adminNotes);

      return {
        success: !!report,
        report,
        message: input.approved ? "Report approved" : "Report denied",
      };
    }),

  // Generate all daily reports (5 PM batch)
  generateAllDailyReports: adminProcedure.query(async () => {
    const reports = {
      luckyai: await generateLuckyAIReport(),
      fraudai: await generateFraudAIReport(),
      gameai: await generateGameAIReport(),
      slotsai: await generateSlotsAIReport(),
      bingoai: await generateBingoAIReport(),
      pokerai: await generatePokerAIReport(),
      sportsai: await generateSportsAIReport(),
    };

    return {
      success: true,
      reports,
      generatedAt: new Date().toISOString(),
      message: "All daily reports generated successfully",
    };
  }),
});