/**
 * @jest-environment node
 */
import { DrizzleDatabase } from "../drizzle";
import { DatabaseConfig } from "../types";
import Database from "better-sqlite3";
import { drizzle } from "drizzle-orm/better-sqlite3";
import * as schema from "@fitai/database";

describe("DrizzleDatabase", () => {
  let db: DrizzleDatabase;
  let sqlite: Database.Database;
  let drizzleDb: ReturnType<typeof drizzle>;

  beforeEach(async () => {
    // Create in-memory SQLite database
    sqlite = new Database(":memory:");
    drizzleDb = drizzle(sqlite, { schema });

    const config: DatabaseConfig = {
      type: "sqlite",
      connection: { filename: ":memory:" },
      options: { logging: false },
    };

    // Initialize DrizzleDatabase with the in-memory db
    db = new DrizzleDatabase(config, drizzleDb as any);
    await db.connect();
  });

  afterEach(async () => {
    await db.disconnect();
    sqlite.close();
  });

  describe("User Operations", () => {
    it("should create and retrieve a user", async () => {
      const newUser = {
        email: "test@example.com",
        firstName: "Test",
        lastName: "User",
        password: "password123",
        role: "client" as const,
      };

      const createdUser = await db.createUser(newUser);
      expect(createdUser).toBeDefined();
      expect(createdUser.id).toBeDefined();
      expect(createdUser.email).toBe(newUser.email);

      const fetchedUser = await db.getUserById(createdUser.id);
      expect(fetchedUser).toBeDefined();
      expect(fetchedUser?.id).toBe(createdUser.id);
      expect(fetchedUser?.email).toBe(createdUser.email);
      // SQLite/Drizzle might truncate ms or handle dates differently in test env
      expect(new Date(fetchedUser!.createdAt).getTime()).toBeLessThanOrEqual(
        createdUser.createdAt.getTime(),
      );
      expect(new Date(fetchedUser!.updatedAt).getTime()).toBeLessThanOrEqual(
        createdUser.updatedAt.getTime(),
      );
    });

    it("should update a user", async () => {
      const user = await db.createUser({
        email: "update@example.com",
        firstName: "Update",
        lastName: "Me",
        password: "password",
        role: "client",
      });

      const updated = await db.updateUser(user.id, { firstName: "Updated" });
      expect(updated?.firstName).toBe("Updated");

      const fetched = await db.getUserById(user.id);
      expect(fetched?.firstName).toBe("Updated");
    });

    it("should delete a user", async () => {
      const user = await db.createUser({
        email: "delete@example.com",
        firstName: "Delete",
        lastName: "Me",
        password: "password",
        role: "client",
      });

      const deleted = await db.deleteUser(user.id);
      expect(deleted).toBe(true);

      const fetched = await db.getUserById(user.id);
      expect(fetched).toBeNull();
    });
  });

  describe("Client Operations", () => {
    it("should create and retrieve a client", async () => {
      const user = await db.createUser({
        email: "client@example.com",
        firstName: "Client",
        lastName: "User",
        password: "password",
        role: "client",
      });

      const newClient = {
        userId: user.id,
        membershipType: "basic" as const,
        membershipStatus: "active" as const,
        joinDate: new Date(),
      };

      const createdClient = await db.createClient(newClient);
      expect(createdClient).toBeDefined();
      expect(createdClient.userId).toBe(user.id);

      const fetchedClient = await db.getClientById(createdClient.id);
      expect(fetchedClient).toBeDefined();
      expect(fetchedClient?.id).toBe(createdClient.id);
      expect(fetchedClient?.userId).toBe(createdClient.userId);
      expect(fetchedClient?.membershipType).toBe(createdClient.membershipType);
    });
  });

  describe("Fitness Profile Operations", () => {
    it("should create and retrieve a fitness profile", async () => {
      const user = await db.createUser({
        email: "profile@example.com",
        firstName: "Profile",
        lastName: "User",
        password: "password",
        role: "client",
      });

      const newProfile = {
        userId: user.id,
        height: 180,
        weight: 75,
        age: 30,
        gender: "male" as const,
        activityLevel: "moderately_active" as const,
        fitnessGoals: ["weight_loss"],
        exerciseHabits: "None",
        dietHabits: "None",
        medicalConditions: "None",
      };

      const createdProfile = await db.createFitnessProfile(newProfile as any);
      expect(createdProfile).toBeDefined();
      expect(createdProfile.userId).toBe(user.id);

      const fetchedProfile = await db.getFitnessProfileByUserId(user.id);
      expect(fetchedProfile).toBeDefined();
      expect(fetchedProfile?.userId).toBe(user.id);
      expect(fetchedProfile?.fitnessGoals).toEqual(
        expect.arrayContaining(["weight_loss"]),
      );
    });
  });

  describe("Attendance Operations", () => {
    it("should check in and check out", async () => {
      const user = await db.createUser({
        email: "attendance@example.com",
        firstName: "Attendance",
        lastName: "User",
        password: "password",
        role: "client",
      });

      const checkIn = await db.checkIn(user.id, "gym");
      expect(checkIn).toBeDefined();
      expect(checkIn.checkOutTime).toBeUndefined();

      const activeCheckIn = await db.getActiveCheckIn(user.id);
      expect(activeCheckIn).toBeDefined();
      expect(activeCheckIn?.id).toBe(checkIn.id);

      const checkOut = await db.checkOut(checkIn.id);
      expect(checkOut?.checkOutTime).toBeDefined();

      const activeCheckInAfter = await db.getActiveCheckIn(user.id);
      expect(activeCheckInAfter).toBeNull();
    });
  });

  describe("Batch Query Operations (Phase 9)", () => {
    describe("getClientsByUserIds", () => {
      it("should return clients for multiple users", async () => {
        // Create users
        const user1 = await db.createUser({
          email: "batch1@example.com",
          firstName: "Batch",
          lastName: "User1",
          password: "password",
          role: "client",
        });
        const user2 = await db.createUser({
          email: "batch2@example.com",
          firstName: "Batch",
          lastName: "User2",
          password: "password",
          role: "client",
        });
        const user3 = await db.createUser({
          email: "batch3@example.com",
          firstName: "Batch",
          lastName: "User3",
          password: "password",
          role: "client",
        });

        // Create clients for user1 and user2 only
        await db.createClient({
          userId: user1.id,
          membershipType: "basic",
          membershipStatus: "active",
          joinDate: new Date(),
        });
        await db.createClient({
          userId: user2.id,
          membershipType: "premium",
          membershipStatus: "active",
          joinDate: new Date(),
        });

        // Batch load clients
        const clients = await db.getClientsByUserIds([
          user1.id,
          user2.id,
          user3.id,
        ]);

        expect(clients).toHaveLength(2);
        expect(clients.map((c) => c.userId).sort()).toEqual(
          [user1.id, user2.id].sort(),
        );
        expect(clients.find((c) => c.userId === user3.id)).toBeUndefined();
      });

      it("should return empty array for empty input", async () => {
        const clients = await db.getClientsByUserIds([]);
        expect(clients).toEqual([]);
      });

      it("should return empty array when no clients exist for users", async () => {
        const clients = await db.getClientsByUserIds(["nonexistent-id"]);
        expect(clients).toEqual([]);
      });
    });

    describe("getAttendanceHistoriesByUserIds", () => {
      it("should return attendance records for multiple users", async () => {
        const user1 = await db.createUser({
          email: "attendance1@example.com",
          firstName: "Attendance",
          lastName: "User1",
          password: "password",
          role: "client",
        });
        const user2 = await db.createUser({
          email: "attendance2@example.com",
          firstName: "Attendance",
          lastName: "User2",
          password: "password",
          role: "client",
        });

        // Create attendance records
        await db.checkIn(user1.id, "gym");
        await db.checkIn(user1.id, "gym");
        await db.checkIn(user2.id, "gym");

        const attendances = await db.getAttendanceHistoriesByUserIds([
          user1.id,
          user2.id,
        ]);

        expect(attendances.length).toBeGreaterThanOrEqual(3);
        const user1Records = attendances.filter((a) => a.userId === user1.id);
        const user2Records = attendances.filter((a) => a.userId === user2.id);
        expect(user1Records.length).toBeGreaterThanOrEqual(2);
        expect(user2Records.length).toBeGreaterThanOrEqual(1);
      });

      it("should return records ordered by checkInTime DESC", async () => {
        const user = await db.createUser({
          email: "order@example.com",
          firstName: "Order",
          lastName: "Test",
          password: "password",
          role: "client",
        });

        // Create multiple check-ins with slight delays
        const checkIn1 = await db.checkIn(user.id, "gym");
        await new Promise((resolve) => setTimeout(resolve, 10));
        const checkIn2 = await db.checkIn(user.id, "gym");

        const attendances = await db.getAttendanceHistoriesByUserIds([user.id]);

        expect(attendances.length).toBeGreaterThanOrEqual(2);
        // Most recent should be first
        expect(
          new Date(attendances[0].checkInTime).getTime(),
        ).toBeGreaterThanOrEqual(
          new Date(attendances[1].checkInTime).getTime(),
        );
      });

      it("should return empty array for empty input", async () => {
        const attendances = await db.getAttendanceHistoriesByUserIds([]);
        expect(attendances).toEqual([]);
      });
    });

    describe("getActiveCheckInsByUserIds", () => {
      it("should return only active check-ins", async () => {
        const user1 = await db.createUser({
          email: "active1@example.com",
          firstName: "Active",
          lastName: "User1",
          password: "password",
          role: "client",
        });
        const user2 = await db.createUser({
          email: "active2@example.com",
          firstName: "Active",
          lastName: "User2",
          password: "password",
          role: "client",
        });

        // User1: check in and check out
        const checkIn1 = await db.checkIn(user1.id, "gym");
        await db.checkOut(checkIn1.id);

        // User2: check in only (active)
        const checkIn2 = await db.checkIn(user2.id, "gym");

        const activeCheckIns = await db.getActiveCheckInsByUserIds([
          user1.id,
          user2.id,
        ]);

        expect(activeCheckIns).toHaveLength(1);
        expect(activeCheckIns[0].userId).toBe(user2.id);
        expect(activeCheckIns[0].checkOutTime).toBeUndefined();
      });

      it("should return empty array when no active check-ins exist", async () => {
        const user = await db.createUser({
          email: "noactive@example.com",
          firstName: "NoActive",
          lastName: "User",
          password: "password",
          role: "client",
        });

        const checkIn = await db.checkIn(user.id, "gym");
        await db.checkOut(checkIn.id);

        const activeCheckIns = await db.getActiveCheckInsByUserIds([user.id]);
        expect(activeCheckIns).toEqual([]);
      });

      it("should return empty array for empty input", async () => {
        const activeCheckIns = await db.getActiveCheckInsByUserIds([]);
        expect(activeCheckIns).toEqual([]);
      });
    });

    describe("getRecommendationsByUserIds", () => {
      it("should return recommendations for multiple users", async () => {
        const user1 = await db.createUser({
          email: "rec1@example.com",
          firstName: "Rec",
          lastName: "User1",
          password: "password",
          role: "client",
        });
        const user2 = await db.createUser({
          email: "rec2@example.com",
          firstName: "Rec",
          lastName: "User2",
          password: "password",
          role: "client",
        });

        // Create recommendations
        // Create fitness profiles (required for recommendations)
        const profile1 = await db.createFitnessProfile({
          userId: user1.id,
          height: 180,
          weight: 75,
          age: 30,
          gender: "male",
          activityLevel: "moderately_active",
        } as any);

        const profile2 = await db.createFitnessProfile({
          userId: user2.id,
          height: 165,
          weight: 60,
          age: 25,
          gender: "female",
          activityLevel: "lightly_active",
        } as any);

        await db.createRecommendation({
          userId: user1.id,
          fitnessProfileId: profile1.id,
          recommendationText: "Test recommendation 1",
          activityPlan: "Activity plan 1",
          dietPlan: "Diet plan 1",
          status: "pending",
        } as any);
        await db.createRecommendation({
          userId: user2.id,
          fitnessProfileId: profile2.id,
          recommendationText: "Test recommendation 2",
          activityPlan: "Activity plan 2",
          dietPlan: "Diet plan 2",
          status: "pending",
        } as any);

        const recommendations = await db.getRecommendationsByUserIds([
          user1.id,
          user2.id,
        ]);

        expect(recommendations.length).toBeGreaterThanOrEqual(2);
        const user1Recs = recommendations.filter((r) => r.userId === user1.id);
        const user2Recs = recommendations.filter((r) => r.userId === user2.id);
        expect(user1Recs.length).toBeGreaterThanOrEqual(1);
        expect(user2Recs.length).toBeGreaterThanOrEqual(1);
      });

      it("should return empty array for empty input", async () => {
        const recommendations = await db.getRecommendationsByUserIds([]);
        expect(recommendations).toEqual([]);
      });
    });

    describe("getFitnessGoalsByUserIds", () => {
      it("should return fitness goals for multiple users", async () => {
        const user1 = await db.createUser({
          email: "goal1@example.com",
          firstName: "Goal",
          lastName: "User1",
          password: "password",
          role: "client",
        });
        const user2 = await db.createUser({
          email: "goal2@example.com",
          firstName: "Goal",
          lastName: "User2",
          password: "password",
          role: "client",
        });

        // Create fitness goals
        await db.createFitnessGoal({
          userId: user1.id,
          goalType: "weight_target",
          title: "Lose weight",
          targetValue: 10,
          currentValue: 0,
          unit: "kg",
          targetDate: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
          status: "active",
        } as any);
        await db.createFitnessGoal({
          userId: user2.id,
          goalType: "strength_milestone",
          title: "Gain muscle",
          targetValue: 5,
          currentValue: 0,
          unit: "kg",
          targetDate: new Date(Date.now() + 60 * 24 * 60 * 60 * 1000),
          status: "active",
        } as any);

        const goals = await db.getFitnessGoalsByUserIds([user1.id, user2.id]);

        expect(goals.length).toBeGreaterThanOrEqual(2);
        const user1Goals = goals.filter((g) => g.userId === user1.id);
        const user2Goals = goals.filter((g) => g.userId === user2.id);
        expect(user1Goals.length).toBeGreaterThanOrEqual(1);
        expect(user2Goals.length).toBeGreaterThanOrEqual(1);
      });

      it("should return empty array for empty input", async () => {
        const goals = await db.getFitnessGoalsByUserIds([]);
        expect(goals).toEqual([]);
      });
    });

    describe("Batch Query Performance", () => {
      it("should be more efficient than individual queries", async () => {
        // Create 10 users with clients
        const users = [];
        for (let i = 0; i < 10; i++) {
          const user = await db.createUser({
            email: `perf${i}@example.com`,
            firstName: "Perf",
            lastName: `User${i}`,
            password: "password",
            role: "client",
          });
          await db.createClient({
            userId: user.id,
            membershipType: "basic",
            membershipStatus: "active",
            joinDate: new Date(),
          });
          users.push(user);
        }

        const userIds = users.map((u) => u.id);

        // Batch query (should be 1 query)
        const batchStart = Date.now();
        const batchClients = await db.getClientsByUserIds(userIds);
        const batchTime = Date.now() - batchStart;

        // Individual queries (should be 10 queries)
        const individualStart = Date.now();
        const individualClients = [];
        for (const userId of userIds) {
          const client = await db.getClientByUserId(userId);
          if (client) individualClients.push(client);
        }
        const individualTime = Date.now() - individualStart;

        // Verify same results
        expect(batchClients.length).toBe(individualClients.length);
        expect(batchClients.length).toBe(10);

        // Batch should be faster (or at least not significantly slower)
        // In practice, batch is much faster, but in-memory DB might not show huge difference
        expect(batchTime).toBeLessThanOrEqual(individualTime * 2);
      });
    });
  });
});