import { describe, it, expect, vi, beforeEach } from "vitest";
import {
  AIEmployeeRole,
  TaskStatus,
  DutyReportStatus,
  createAITask,
  getAIEmployeeTasks,
  updateTaskStatus,
  submitAIDutyReport,
} from "./aiEmployeeSystem.ts";

// Mock LLM calls
vi.mock("../_core/llm", () => ({
  invokeLLM: vi.fn(async () => ({
    choices: [
      {
        message: {
          content: "Mock AI response for testing",
        },
      },
    ],
  })),
}));

describe("AI Employee System", () => {
  describe("Task Management", () => {
    it("should create a new task for an AI employee", async () => {
      const task = await createAITask(
        AIEmployeeRole.FRAUD_AI,
        "Analyze fraud patterns",
        "Deep analysis of Q1 fraud patterns",
        "high"
      );

      expect(task).toBeDefined();
      expect(task.employeeRole).toBe(AIEmployeeRole.FRAUD_AI);
      expect(task.title).toBe("Analyze fraud patterns");
      expect(task.status).toBe(TaskStatus.ASSIGNED);
      expect(task.priority).toBe("high");
    });

    it("should get tasks for an AI employee", async () => {
      const tasks = await getAIEmployeeTasks(AIEmployeeRole.GAME_AI);
      expect(Array.isArray(tasks)).toBe(true);
    });

    it("should update task status", async () => {
      const task = await updateTaskStatus(1, TaskStatus.IN_PROGRESS);
      expect(task === null || task?.status === TaskStatus.IN_PROGRESS).toBe(true);
    });
  });

  describe("Duty Reports", () => {
    it("should submit a duty report", async () => {
      const report = await submitAIDutyReport(
        AIEmployeeRole.LUCKY_AI,
        12,
        ["Improve fraud detection accuracy", "Optimize game performance"],
        "Daily operations completed successfully"
      );

      expect(report).toBeDefined();
      expect(report.employeeRole).toBe(AIEmployeeRole.LUCKY_AI);
      expect(report.tasksCompleted).toBe(12);
      expect(report.recommendations.length).toBe(2);
      expect(report.status).toBe(DutyReportStatus.SUBMITTED);
    });

    it("should have correct report date", async () => {
      const report = await submitAIDutyReport(
        AIEmployeeRole.FRAUD_AI,
        5,
        [],
        "Fraud detection completed"
      );

      const today = new Date().toISOString().split("T")[0];
      expect(report.reportDate).toBe(today);
    });
  });

  describe("AI Employee Roles", () => {
    it("should have all required AI employee roles", () => {
      const roles = Object.values(AIEmployeeRole);
      expect(roles).toContain(AIEmployeeRole.LUCKY_AI);
      expect(roles).toContain(AIEmployeeRole.FRAUD_AI);
      expect(roles).toContain(AIEmployeeRole.GAME_AI);
      expect(roles).toContain(AIEmployeeRole.SLOTS_AI);
      expect(roles).toContain(AIEmployeeRole.BINGO_AI);
      expect(roles).toContain(AIEmployeeRole.POKER_AI);
      expect(roles).toContain(AIEmployeeRole.SPORTS_AI);
    });
  });

  describe("Task Status Transitions", () => {
    it("should have valid task statuses", () => {
      const statuses = Object.values(TaskStatus);
      expect(statuses).toContain(TaskStatus.ASSIGNED);
      expect(statuses).toContain(TaskStatus.IN_PROGRESS);
      expect(statuses).toContain(TaskStatus.SUBMITTED);
      expect(statuses).toContain(TaskStatus.APPROVED);
      expect(statuses).toContain(TaskStatus.DENIED);
      expect(statuses).toContain(TaskStatus.COMPLETED);
    });
  });

  describe("Duty Report Status", () => {
    it("should have valid duty report statuses", () => {
      const statuses = Object.values(DutyReportStatus);
      expect(statuses).toContain(DutyReportStatus.SUBMITTED);
      expect(statuses).toContain(DutyReportStatus.PENDING_REVIEW);
      expect(statuses).toContain(DutyReportStatus.APPROVED);
      expect(statuses).toContain(DutyReportStatus.DENIED);
      expect(statuses).toContain(DutyReportStatus.REVISED);
    });
  });
});