import {
  hasFreeBusyConflict,
  useAttendeesFreeBusy,
} from "@/components/Attendees/useFreeBusy";
import * as getFreeBusyREPORT from "@/features/Events/api/getFreeBusyForAddedAttendeesREPORT";
import * as getFreeBusyPOST from "@/features/Events/api/getFreeBusyForEventAttendeesPOST";
import * as getUserData from "@/features/Events/api/getUserDataFromEmail";
import { renderHook, waitFor } from "@testing-library/react";

jest.mock("moment-timezone", () => {
  const actual = jest.requireActual("moment-timezone");
  return actual;
});

jest.mock("@/features/Events/api/getUserDataFromEmail");
jest.mock("@/features/Events/api/getFreeBusyForAddedAttendeesREPORT");
jest.mock("@/features/Events/api/getFreeBusyForEventAttendeesPOST");

const mockGetUserData = getUserData.getUserDataFromEmail as jest.MockedFunction<
  typeof getUserData.getUserDataFromEmail
>;
const mockREPORT =
  getFreeBusyREPORT.getFreeBusyForAddedAttendeesREPORT as jest.MockedFunction<
    typeof getFreeBusyREPORT.getFreeBusyForAddedAttendeesREPORT
  >;
const mockPOST =
  getFreeBusyPOST.getFreeBusyForEventAttendeesPOST as jest.MockedFunction<
    typeof getFreeBusyPOST.getFreeBusyForEventAttendeesPOST
  >;

const START = "2026-03-14T14:00:00";
const END = "2026-03-14T15:00:00";
const TZ = "Europe/Paris";

describe("hasFreeBusyConflict", () => {
  it("returns false for non-vcalendar data", () => {
    expect(hasFreeBusyConflict({ data: ["not-vcalendar", [], []] })).toBe(
      false
    );
  });

  it("returns false when vfreebusy has no freebusy property", () => {
    const data = {
      data: [
        "vcalendar",
        [],
        [
          [
            "vfreebusy",
            [["dtstart", {}, "date-time", "2026-03-14T14:00:00Z"]],
            [],
          ],
        ],
      ],
    };
    expect(hasFreeBusyConflict(data)).toBe(false);
  });

  it("returns true when vfreebusy contains a freebusy property", () => {
    const data = {
      data: [
        "vcalendar",
        [],
        [
          [
            "vfreebusy",
            [
              ["dtstart", {}, "date-time", "2026-03-14T14:00:00Z"],
              ["freebusy", {}, "period", "2026-03-14T14:00:00Z/PT1H"],
            ],
            [],
          ],
        ],
      ],
    };
    expect(hasFreeBusyConflict(data)).toBe(true);
  });

  it("returns false for malformed data without throwing", () => {
    expect(hasFreeBusyConflict(null)).toBe(false);
    expect(hasFreeBusyConflict("garbage")).toBe(false);
    expect(hasFreeBusyConflict({ data: null })).toBe(false);
  });
});

describe("useAttendeesFreeBusy — Flow B (new attendees)", () => {
  beforeEach(() => jest.clearAllMocks());

  const newAttendee = { email: "alice@example.com", userId: "user-alice" };

  it("shows loading then free for a new attendee", async () => {
    mockREPORT.mockResolvedValue(false);

    const { result } = renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [],
        newAttendees: [newAttendee],
        start: START,
        end: END,
        timezone: TZ,
      })
    );

    expect(result.current[newAttendee.email]).toBe("loading");

    await waitFor(() => expect(result.current[newAttendee.email]).toBe("free"));
  });

  it("shows busy when REPORT returns true", async () => {
    mockREPORT.mockResolvedValue(true);

    const { result } = renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [],
        newAttendees: [newAttendee],
        start: START,
        end: END,
        timezone: TZ,
      })
    );

    await waitFor(() => expect(result.current[newAttendee.email]).toBe("busy"));
  });

  it("shows unknown when REPORT throws", async () => {
    mockREPORT.mockRejectedValue(new Error("network error"));

    const { result } = renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [],
        newAttendees: [newAttendee],
        start: START,
        end: END,
        timezone: TZ,
      })
    );

    await waitFor(() =>
      expect(result.current[newAttendee.email]).toBe("unknown")
    );
  });

  it("resolves userId via getUserDataFromEmail when not provided", async () => {
    mockGetUserData.mockResolvedValue([{ _id: "resolved-id" }] as never);
    mockREPORT.mockResolvedValue(false);

    const attendeeWithoutId = { email: "bob@example.com" };

    const { result } = renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [],
        newAttendees: [attendeeWithoutId],
        start: START,
        end: END,
        timezone: TZ,
      })
    );

    await waitFor(() =>
      expect(result.current[attendeeWithoutId.email]).toBe("free")
    );
    expect(mockGetUserData).toHaveBeenCalledWith("bob@example.com");
    expect(mockREPORT).toHaveBeenCalledWith(
      "resolved-id",
      expect.any(String),
      expect.any(String)
    );
  });

  it("shows unknown when userId cannot be resolved", async () => {
    mockGetUserData.mockResolvedValue([]);

    const { result } = renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [],
        newAttendees: [{ email: "ghost@example.com" }],
        start: START,
        end: END,
        timezone: TZ,
      })
    );

    await waitFor(() =>
      expect(result.current["ghost@example.com"]).toBe("unknown")
    );
    expect(mockREPORT).not.toHaveBeenCalled();
  });

  it("does not re-fetch an attendee already fetched", async () => {
    mockREPORT.mockResolvedValue(false);

    const { result, rerender } = renderHook(
      ({ attendees }) =>
        useAttendeesFreeBusy({
          existingAttendees: [],
          newAttendees: attendees,
          start: START,
          end: END,
          timezone: TZ,
        }),
      { initialProps: { attendees: [newAttendee] } }
    );

    await waitFor(() => expect(result.current[newAttendee.email]).toBe("free"));

    rerender({ attendees: [newAttendee] });
    expect(mockREPORT).toHaveBeenCalledTimes(1);
  });

  it("removes departed attendee from the map", async () => {
    mockREPORT.mockResolvedValue(false);

    const { result, rerender } = renderHook(
      ({ attendees }) =>
        useAttendeesFreeBusy({
          existingAttendees: [],
          newAttendees: attendees,
          start: START,
          end: END,
          timezone: TZ,
        }),
      { initialProps: { attendees: [newAttendee] } }
    );

    await waitFor(() => expect(result.current[newAttendee.email]).toBe("free"));

    rerender({ attendees: [] });

    await waitFor(() =>
      expect(result.current[newAttendee.email]).toBeUndefined()
    );
  });

  it("invalidates cache and re-fetches when time window changes", async () => {
    mockREPORT.mockResolvedValue(false);

    const { result, rerender } = renderHook(
      ({ start, end }) =>
        useAttendeesFreeBusy({
          existingAttendees: [],
          newAttendees: [newAttendee],
          start,
          end,
          timezone: TZ,
        }),
      { initialProps: { start: START, end: END } }
    );

    await waitFor(() => expect(result.current[newAttendee.email]).toBe("free"));

    rerender({ start: "2026-03-15T14:00:00", end: "2026-03-15T15:00:00" });

    await waitFor(() => expect(result.current[newAttendee.email]).toBe("free"));

    expect(mockREPORT).toHaveBeenCalledTimes(2);
  });

  it("passes UTC-converted iCal times to the API", async () => {
    mockREPORT.mockResolvedValue(false);

    renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [],
        newAttendees: [newAttendee],
        start: "2026-03-14T16:00:00", // 16:00 Paris = 15:00 UTC in winter
        end: "2026-03-14T17:00:00",
        timezone: "Europe/Paris",
      })
    );

    await waitFor(() => expect(mockREPORT).toHaveBeenCalled());

    // Paris is UTC+1 in March (before DST), so 16:00 → 15:00 UTC
    expect(mockREPORT).toHaveBeenCalledWith(
      "user-alice",
      "20260314T150000",
      "20260314T160000"
    );
  });
});

describe("useAttendeesFreeBusy — Flow A (existing attendees)", () => {
  beforeEach(() => jest.clearAllMocks());

  const existingAttendee = { email: "carol@example.com", userId: "user-carol" };

  it("does not fetch when eventUid is missing", () => {
    renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [existingAttendee],
        newAttendees: [],
        start: START,
        end: END,
        timezone: TZ,
      })
    );

    expect(mockPOST).not.toHaveBeenCalled();
  });

  it("shows loading then free for existing attendees", async () => {
    mockPOST.mockResolvedValue({ "user-carol": false });

    const { result } = renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [existingAttendee],
        newAttendees: [],
        start: START,
        end: END,
        timezone: TZ,
        eventUid: "event-123",
      })
    );

    expect(result.current[existingAttendee.email]).toBe("loading");

    await waitFor(() =>
      expect(result.current[existingAttendee.email]).toBe("free")
    );
  });

  it("shows busy when POST returns busy for userId", async () => {
    mockPOST.mockResolvedValue({ "user-carol": true });

    const { result } = renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [existingAttendee],
        newAttendees: [],
        start: START,
        end: END,
        timezone: TZ,
        eventUid: "event-123",
      })
    );

    await waitFor(() =>
      expect(result.current[existingAttendee.email]).toBe("busy")
    );
  });

  it("shows unknown when POST throws", async () => {
    mockPOST.mockRejectedValue(new Error("server error"));

    const { result } = renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [existingAttendee],
        newAttendees: [],
        start: START,
        end: END,
        timezone: TZ,
        eventUid: "event-123",
      })
    );

    await waitFor(() =>
      expect(result.current[existingAttendee.email]).toBe("unknown")
    );
  });

  it("passes the eventUid to the POST API", async () => {
    mockPOST.mockResolvedValue({ "user-carol": false });

    renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [existingAttendee],
        newAttendees: [],
        start: START,
        end: END,
        timezone: TZ,
        eventUid: "event-abc",
      })
    );

    await waitFor(() => expect(mockPOST).toHaveBeenCalled());
    expect(mockPOST).toHaveBeenCalledWith(
      ["user-carol"],
      expect.any(String),
      expect.any(String),
      "event-abc"
    );
  });
});

describe("useAttendeesFreeBusy — enabled flag", () => {
  it("does not fetch when disabled", () => {
    renderHook(() =>
      useAttendeesFreeBusy({
        existingAttendees: [{ email: "x@x.com", userId: "uid" }],
        newAttendees: [{ email: "y@y.com", userId: "uid2" }],
        start: START,
        end: END,
        timezone: TZ,
        eventUid: "event-123",
        enabled: false,
      })
    );

    expect(mockPOST).not.toHaveBeenCalled();
    expect(mockREPORT).not.toHaveBeenCalled();
  });
});