import SettingsPage from "@/features/Settings/SettingsPage";
import settingsReducer from "@/features/Settings/SettingsSlice";
import userReducer, {
  getOpenPaasUserDataAsync,
} from "@/features/User/userSlice";
import { api } from "@/utils/apiUtils";
import { configureStore } from "@reduxjs/toolkit";
import "@testing-library/jest-dom";
import { fireEvent, screen, waitFor } from "@testing-library/react";
import { renderWithProviders } from "../../utils/Renderwithproviders";

jest.mock("@/utils/apiUtils");

const basePreloadedState = {
  user: {
    userData: {
      sub: "test",
      email: "test@test.com",
      family_name: "Doe",
      name: "John",
      sid: "mockSid",
      openpaasId: "667037022b752d0026472254",
    },
    organiserData: null,
    tokens: null,
    coreConfig: {
      language: "en",
      datetime: { timeZone: "UTC" },
    },
    alarmEmailsEnabled: false,
    loading: false,
    error: null,
  },
  settings: {
    language: "en",
    timeZone: "UTC",
    isBrowserDefaultTimeZone: false,
    view: "settings",
    businessHours: {
      start: "8:0",
      end: "19:0",
      daysOfWeek: [1, 2, 3, 4, 5],
    },
    workingDays: false,
  },
};

describe("Working Days and Business Hours Settings", () => {
  beforeEach(() => {
    jest.clearAllMocks();
    (api.patch as jest.Mock).mockResolvedValue({ status: 204 });
  });

  describe("Initial rendering", () => {
    it("renders the working days section with day selector", () => {
      renderWithProviders(<SettingsPage />, basePreloadedState);

      expect(
        screen.getByText("settings.chooseWorkingDays")
      ).toBeInTheDocument();
    });

    it("renders the show only working days toggle", () => {
      renderWithProviders(<SettingsPage />, basePreloadedState);

      expect(
        screen.getByRole("switch", { name: /settings.showOnlyWorkingDays/i })
      ).toBeInTheDocument();
    });

    it("shows working days toggle as unchecked when workingDays is false", () => {
      renderWithProviders(<SettingsPage />, basePreloadedState);

      const toggle = screen.getByRole("switch", {
        name: /settings.showOnlyWorkingDays/i,
      }) as HTMLInputElement;
      expect(toggle.checked).toBe(false);
    });

    it("shows working days toggle as checked when workingDays is true", () => {
      renderWithProviders(<SettingsPage />, {
        ...basePreloadedState,
        settings: { ...basePreloadedState.settings, workingDays: true },
      });

      const toggle = screen.getByRole("switch", {
        name: /settings.showOnlyWorkingDays/i,
      }) as HTMLInputElement;
      expect(toggle.checked).toBe(true);
    });

    it("shows working days toggle as unchecked when workingDays is null", () => {
      renderWithProviders(<SettingsPage />, {
        ...basePreloadedState,
        settings: { ...basePreloadedState.settings, workingDays: null },
      });

      const toggle = screen.getByRole("switch", {
        name: /settings.showOnlyWorkingDays/i,
      }) as HTMLInputElement;
      expect(toggle.checked).toBe(false);
    });
  });

  describe("workingDays toggle", () => {
    it("updates workingDays immediately (optimistic update) and calls API", async () => {
      const { store } = renderWithProviders(
        <SettingsPage />,
        basePreloadedState
      );

      const toggle = screen.getByRole("switch", {
        name: /settings.showOnlyWorkingDays/i,
      });
      fireEvent.click(toggle);

      await waitFor(() => {
        expect(store.getState().settings.workingDays).toBe(true);
      });

      await waitFor(() => {
        expect(api.patch).toHaveBeenCalledWith(
          "api/configurations?scope=user",
          expect.objectContaining({
            json: expect.arrayContaining([
              expect.objectContaining({
                name: "linagora.esn.calendar",
                configurations: expect.arrayContaining([
                  expect.objectContaining({
                    name: "workingDays",
                    value: true,
                  }),
                ]),
              }),
            ]),
          })
        );
      });
    });

    it("rolls back workingDays if API call fails", async () => {
      (api.patch as jest.Mock).mockRejectedValue(new Error("API Error"));

      const { store } = renderWithProviders(
        <SettingsPage />,
        basePreloadedState
      );

      const toggle = screen.getByRole("switch", {
        name: /settings.showOnlyWorkingDays/i,
      });
      fireEvent.click(toggle);

      await waitFor(
        () => {
          expect(store.getState().settings.workingDays).toBe(false);
        },
        { timeout: 3000 }
      );

      await waitFor(() => {
        expect(
          screen.getByText("settings.workingDaysUpdateError")
        ).toBeInTheDocument();
      });
    });

    it("toggles workingDays from true to false", async () => {
      const { store } = renderWithProviders(<SettingsPage />, {
        ...basePreloadedState,
        settings: { ...basePreloadedState.settings, workingDays: true },
      });

      const toggle = screen.getByRole("switch", {
        name: /settings.showOnlyWorkingDays/i,
      });
      fireEvent.click(toggle);

      await waitFor(() => {
        expect(store.getState().settings.workingDays).toBe(false);
      });

      await waitFor(() => {
        expect(api.patch).toHaveBeenCalledWith(
          "api/configurations?scope=user",
          expect.objectContaining({
            json: expect.arrayContaining([
              expect.objectContaining({
                name: "linagora.esn.calendar",
                configurations: expect.arrayContaining([
                  expect.objectContaining({
                    name: "workingDays",
                    value: false,
                  }),
                ]),
              }),
            ]),
          })
        );
      });
    });
  });

  describe("businessHours day selector", () => {
    it("updates businessHours in Redux immediately when a day is clicked", async () => {
      const { store } = renderWithProviders(
        <SettingsPage />,
        basePreloadedState
      );

      // Sunday (0) is not in initial daysOfWeek [1,2,3,4,5], click it to add
      const sundayButton = screen.getByRole("button", {
        name: /sunday/i,
      });
      fireEvent.click(sundayButton);

      await waitFor(() => {
        expect(store.getState().settings.businessHours?.daysOfWeek).toContain(
          0
        );
      });
    });

    it("removes a day from businessHours when an already selected day is clicked", async () => {
      const { store } = renderWithProviders(
        <SettingsPage />,
        basePreloadedState
      );

      // Monday (1) is in initial daysOfWeek, click to remove
      const mondayButton = screen.getByRole("button", { name: /monday/i });
      fireEvent.click(mondayButton);

      await waitFor(() => {
        expect(
          store.getState().settings.businessHours?.daysOfWeek
        ).not.toContain(1);
      });
    });

    it("debounces API call when multiple days are clicked rapidly", async () => {
      jest.useFakeTimers();

      renderWithProviders(<SettingsPage />, basePreloadedState);

      const sundayButton = screen.getByRole("button", { name: /sunday/i });
      const saturdayButton = screen.getByRole("button", { name: /saturday/i });

      fireEvent.click(sundayButton);
      fireEvent.click(saturdayButton);
      fireEvent.click(sundayButton);

      // API should not have been called yet
      expect(api.patch).not.toHaveBeenCalled();

      // Advance timers past debounce threshold
      jest.runAllTimers();

      await waitFor(() => {
        expect(api.patch).toHaveBeenCalledTimes(1);
      });

      jest.useRealTimers();
    });

    it("sends businessHours as array to API", async () => {
      jest.useFakeTimers();

      renderWithProviders(<SettingsPage />, basePreloadedState);

      const sundayButton = screen.getByRole("button", { name: /sunday/i });
      fireEvent.click(sundayButton);

      jest.runAllTimers();

      await waitFor(() => {
        expect(api.patch).toHaveBeenCalledWith(
          "api/configurations?scope=user",
          expect.objectContaining({
            json: expect.arrayContaining([
              expect.objectContaining({
                name: "core",
                configurations: expect.arrayContaining([
                  expect.objectContaining({
                    name: "businessHours",
                    value: expect.arrayContaining([
                      expect.objectContaining({
                        start: "8:0",
                        end: "19:0",
                        daysOfWeek: expect.arrayContaining([0]),
                      }),
                    ]),
                  }),
                ]),
              }),
            ]),
          })
        );
      });

      jest.useRealTimers();
    });

    it("rolls back businessHours if API call fails", async () => {
      jest.useFakeTimers();
      (api.patch as jest.Mock).mockRejectedValue(new Error("API Error"));

      const { store } = renderWithProviders(
        <SettingsPage />,
        basePreloadedState
      );

      const sundayButton = screen.getByRole("button", { name: /sunday/i });
      fireEvent.click(sundayButton);

      jest.runAllTimers();

      await waitFor(
        () => {
          expect(
            store.getState().settings.businessHours?.daysOfWeek
          ).not.toContain(0);
        },
        { timeout: 3000 }
      );

      await waitFor(() => {
        expect(
          screen.getByText("settings.workingDaysUpdateError")
        ).toBeInTheDocument();
      });

      jest.useRealTimers();
    });
  });

  describe("getOpenPaasUserDataAsync integration", () => {
    it("populates businessHours from core module configurations", async () => {
      const store = configureStore({
        reducer: { user: userReducer, settings: settingsReducer },
        preloadedState: {
          user: {
            userData: {
              sub: "test",
              email: "test@test.com",
              family_name: "Doe",
              name: "John",
              sid: "mockSid",
              openpaasId: "667037022b752d0026472254",
            },
            organiserData: null,
            tokens: null,
            coreConfig: { language: "en", datetime: { timeZone: "UTC" } },
            alarmEmailsEnabled: null,
            loading: false,
            error: null,
          },
          settings: {
            language: "en",
            timeZone: "UTC",
            isBrowserDefaultTimeZone: false,
            view: "calendar",
            businessHours: null,
            workingDays: null,
          },
        },
      });

      const mockResponse = {
        id: "667037022b752d0026472254",
        firstname: "John",
        lastname: "Doe",
        preferredEmail: "test@test.com",
        configurations: {
          modules: [
            {
              name: "core",
              configurations: [
                {
                  name: "businessHours",
                  value: [
                    { start: "8:0", end: "19:0", daysOfWeek: [1, 2, 3, 4, 5] },
                  ],
                },
              ],
            },
            {
              name: "linagora.esn.calendar",
              configurations: [{ name: "workingDays", value: true }],
            },
          ],
        },
      };

      await store.dispatch(
        getOpenPaasUserDataAsync.fulfilled(mockResponse, "", undefined)
      );

      const state = store.getState();
      expect(state.settings.businessHours).toEqual({
        start: "8:0",
        end: "19:0",
        daysOfWeek: [1, 2, 3, 4, 5],
      });
      expect(state.settings.workingDays).toBe(true);
    });

    it("sets businessHours to null when not present in API response", async () => {
      const store = configureStore({
        reducer: { user: userReducer, settings: settingsReducer },
        preloadedState: {
          user: {
            userData: {
              sub: "test",
              email: "test@test.com",
              family_name: "Doe",
              name: "John",
              sid: "mockSid",
              openpaasId: "667037022b752d0026472254",
            },
            organiserData: null,
            tokens: null,
            coreConfig: { language: "en", datetime: { timeZone: "UTC" } },
            alarmEmailsEnabled: null,
            loading: false,
            error: null,
          },
          settings: {
            language: "en",
            timeZone: "UTC",
            isBrowserDefaultTimeZone: false,
            view: "calendar",
            businessHours: null,
            workingDays: null,
          },
        },
      });

      const mockResponse = {
        id: "667037022b752d0026472254",
        firstname: "John",
        lastname: "Doe",
        preferredEmail: "test@test.com",
        configurations: {
          modules: [
            {
              name: "core",
              configurations: [],
            },
            {
              name: "linagora.esn.calendar",
              configurations: [{ name: "workingDays", value: null }],
            },
          ],
        },
      };

      await store.dispatch(
        getOpenPaasUserDataAsync.fulfilled(mockResponse, "", undefined)
      );

      const state = store.getState();
      expect(state.settings.businessHours).toBeNull();
      expect(state.settings.workingDays).toBeNull();
    });
  });
});