import {
  useMutation,
  useQueries,
  useQuery,
  useQueryClient,
} from "@tanstack/react-query";
import { api, ENTITY_TYPE } from "../utils/common";
import {
  APIParamsProps,
  EntityListingResponse,
  EntityTableAPIProps,
  viewSettingsDropDownAPIProps,
} from "../../types/common";
import {
  commonGetDropdownDataAPI,
  createSavedFilter,
  deleteSavedFilter,
  getSettingsData,
  saveSettingsData,
  updateSavedFilter,
  viewSettingsDropDown,
} from "../utils/apiColumn";
import { FilterColumnsDataProps } from "../../types/filter";

const entityListingCall = async ({
  page,
  size,
  entity_type = ENTITY_TYPE,
  tabs = {
    columnName: "status",
    sortBy: "ASC",
    value: "",
  },
  sortby = [
    {
      sortColum: "name",
      sortType: "ASC",
    },
    {
      sortColum: "status",
      sortType: "DSC",
    },
  ],
  quickFilter = [],
  attributeFilter = [],
}: EntityTableAPIProps): Promise<{
  responseStatus: number;
  data: EntityListingResponse;
}> => {
  const url = `filter`;

  const body = {
    entity_type,
    tabs,
    sortby,
    quickFilter,
    attributeFilter,
  };

  const params: APIParamsProps = {
    page,
    size,
  };

  const response = await api.post(url, body, { params });

  return { responseStatus: response.status, data: response.data };
};

export const useEntityTableAPI = ({
  page = 0,
  size = 50,
  entity_type = ENTITY_TYPE,
  tabs = {
    columnName: "status",
    sortBy: "ASC",
    value: "",
  },
  quickFilter = [],
  sortby = [
    {
      sortColum: "name",
      sortType: "ASC",
    },
  ],
  attributeFilter = [],
}: EntityTableAPIProps) => {
  const { data, isPending: isTableDataPending } = useQuery({
    queryKey: ["entityTable", page, size, tabs, quickFilter],
    queryFn: () =>
      entityListingCall({
        page,
        size,
        entity_type,
        tabs,
        quickFilter,
        sortby,
        attributeFilter,
      }),
  });

  return {
    tableData: data?.data.data,
    status: data?.responseStatus,
    isTableDataPending,
  };
};

//for saved filter API
export const useSavedFilterAPI = () => {
  const queryClient = useQueryClient();
  const savedMutation = useMutation({
    mutationKey: ["savedFilter"],
    mutationFn: ({
      entity_type,
      payload,
    }: {
      entity_type: string;
      payload: any;
    }) => {
      return createSavedFilter(entity_type, payload);
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ["meta"] });
    },
  });

  return { savedMutation };
};

//for delete filter API
export const useDeleteFilterAPI = () => {
  const queryClient = useQueryClient();
  const deleteMutation = useMutation({
    mutationKey: ["deleteFilter"],
    mutationFn: ({
      entity_type,
      payload,
    }: {
      entity_type: string;
      payload: any;
    }) => {
      return deleteSavedFilter(entity_type, payload);
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ["meta"] });
    },
  });

  return { deleteMutation };
};

// for updating saved filter API
export const useUpdateFilterAPI = () => {
  const queryClient = useQueryClient();

  const updateMutation = useMutation({
    mutationKey: ["updateFilter"],
    mutationFn: ({
      entity_type,
      payload,
    }: {
      entity_type: string;
      payload: any;
    }) => {
      return updateSavedFilter(entity_type, payload);
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ["meta"] });
    },
  });

  return { updateMutation };
};

export const useCommonDropdownAPI = (
  metaData?: FilterColumnsDataProps,
  value?: string
) => {
  // Step 1: Extract all keys and query types
  const dropdownConfigs = (metaData?.column_list || [])
    .filter((col) => col?.datasource_list)
    .map((col) => ({
      key: col.attribute_key,
      dataSourceType: value ?? col.datasource_list ?? "STS",
    }));

  // Step 2: Use useQueries to fetch them all in parallel
  const dropdownResults = useQueries({
    queries: dropdownConfigs.map((cfg) => {
      return {
        queryKey: ["commonDropdown", cfg.dataSourceType],
        queryFn: () => commonGetDropdownDataAPI(cfg.dataSourceType, null),
        enabled: !!cfg.dataSourceType,
      };
    }),
  });

  // Step 3: Map results to keys
  const dropdownData: Record<string, any> = {};
  dropdownConfigs.forEach((cfg, idx) => {
    dropdownData[cfg.key] = dropdownResults[idx].data;
  });

  return { dropdownData };
};

//ALL VIEW SETTINGS API

// export const useSettingsDropDownAPI = () => {
//   const queryClient = useQueryClient();

//   const viewSettingsDropDownMutation = useMutation({
//     mutationKey: ["viewsettingsDropdown"],
//     mutationFn: ({
//       entity_type,
//       column,
//       sort_by,
//     }: {
//       entity_type: string;
//       column: string;
//       sort_by: string;
//     }) => {
//       return viewSettingsDropDown(entity_type, column, sort_by);
//     },
//     // onSuccess: () => {
//     //   queryClient.invalidateQueries({ queryKey: ["meta"] });
//     // },
//   });

//   return { viewSettingsDropDownMutation };

export const useSettingsDropDownAPI = ({
  entity_type,
  column,
  sort_by,
}: viewSettingsDropDownAPIProps) => {
  const {
    data: settingsTabDropdownData,
    isPending: settingsTabDropdownPending,
  } = useQuery({
    queryKey: ["viewsettingsDropdown", entity_type, column, sort_by],
    queryFn: () =>
      viewSettingsDropDown({
        entity_type,
        column,
        sort_by,
      }),
    enabled: !!column && !!entity_type && !!sort_by,
  });

  return { settingsTabDropdownData, settingsTabDropdownPending };
};

export const useSaveSettingsDataAPI = (entity_type: string) => {
  const queryClient = useQueryClient();
  const saveSettingsDataMutation = useMutation({
    mutationKey: ["saveSettingsData", entity_type],
    mutationFn: ({ payload }: { payload: any }) => {
      return saveSettingsData(payload);
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: ["entityTable"],
      });

      queryClient.invalidateQueries({
        queryKey: ["getSettingsData", entity_type],
      });
    },
    onError: (error: any) => {
      const msg = error?.response?.data?.message;
      console.log("Error in saving settings tab data", msg, error);
    },
  });

  return { saveSettingsDataMutation };
};

export const useGetSettingsDataAPI = (entity_type: string) => {
  const { data: getSettingsAPIData } = useQuery({
    queryKey: ["getSettingsData", entity_type],
    queryFn: () => getSettingsData(entity_type),
    enabled: !!entity_type,
  });

  return { getSettingsAPIData };
};