/* eslint-disable @typescript-eslint/no-explicit-any */
import axios, { AxiosInstance } from "axios";

const baseUrl = "https://v2-dot-gwtsession-1226.appspot.com";

const serviceAxios: AxiosInstance = axios.create({
  baseURL: baseUrl,
  headers: {
    "Content-Type": "application/json",
    Accept: "application/json",
  },
});

let eventServiceInstance: any = null;

/**
 * Setup Axios interceptors with eventService.
 *
 * `serviceAxios` is a module-level singleton, so every call appends another pair
 * of interceptors to the same instance. The core builds a fresh EventService per
 * screenId, so the caller's effect re-fires on each screen change and the
 * loader events were being emitted once per screen ever visited. Returns a
 * disposer the caller must run on cleanup.
 */
export const setupServiceInterceptors = (eventService: any) => {
  eventServiceInstance = eventService;

  // Request interceptor - enable loader
  const requestInterceptorId = serviceAxios.interceptors.request.use(
    (config) => {
      if (eventServiceInstance) {
        const handler = eventServiceInstance.emit("REQUEST_START");
        handler?.();
      }
      return config;
    },
    (error) => {
      if (eventServiceInstance) {
        const handler = eventServiceInstance.emit("REQUEST_END");
        handler?.();
      }
      return Promise.reject(error);
    },
  );

  // Response interceptor - disable loader
  const responseInterceptorId = serviceAxios.interceptors.response.use(
    (response) => {
      if (eventServiceInstance) {
        const handler = eventServiceInstance.emit("REQUEST_END");
        handler?.();
      }
      return response;
    },
    (error) => {
      if (eventServiceInstance) {
        const handler = eventServiceInstance.emit("REQUEST_END");
        handler?.();
      }
      return Promise.reject(error);
    },
  );

  return () => {
    serviceAxios.interceptors.request.eject(requestInterceptorId);
    serviceAxios.interceptors.response.eject(responseInterceptorId);
  };
};

const loadScreenService = async (uniqueViewId: string) => {
  if (!uniqueViewId) {
    console.error("Unique view ID is required to load screen service.");
    return;
  }
  try {
    return await serviceAxios.get(
      `/api/metadata/getViewByWidgetGroupId?widgetGroupId=${uniqueViewId}`,
    );
  } catch (error) {
    console.error("Error loading service:", error);
  }
};

const loadScreenByIdService = async (id: string) => {
  if (!id) {
    console.error("ID is required to load screen service.");
    return;
  }
  try {
    return await serviceAxios.get(`/api/metadata/${id}`);
  } catch (error) {
    console.error("Error loading service:", error);
  }
};

const createScreenService = async (
  screenName: string,
  uniqueViewId: string,
) => {
  try {
    return await serviceAxios.post(`/api/metadata/createView`, {
      viewName: screenName,
      widgetGroupId: uniqueViewId,
    });
  } catch (error) {
    console.error("Error creating service:", error);
    throw error;
  }
};

const updateScreenService = async (id: string, data: Record<string, any>) => {
  try {
    const response = await serviceAxios.patch(`/api/metadata`, {
      ...data,
      id,
    });
    return response;
  } catch (error) {
    console.error("Error updating service:", error);
    throw error;
  }
};

const markDefaultScreenService = async (id: string, uniqueViewId: string) => {
  try {
    const response = await serviceAxios.patch(
      `/api/metadata/markAsDefault/${uniqueViewId}/${id}`,
    );
    return response;
  } catch (error) {
    console.error("Error creating service:", error);
    throw error;
  }
};

const deleteScreenService = async (id: string) => {
  try {
    const response = await serviceAxios.delete(`/api/metadata/${id}`);
    return response;
  } catch (error) {
    console.error("Error creating service:", error);
    throw error;
  }
};

export {
  loadScreenService,
  loadScreenByIdService,
  createScreenService,
  updateScreenService,
  markDefaultScreenService,
  deleteScreenService,
};