import { useGetCountriesQuery } from "@/redux/api/master/location/countryApi";
import { useGetStatesQuery } from "@/redux/api/master/location/stateApi";
import { useGetCitiesQuery } from "@/redux/api/master/location/cityApi";
import { useGetAreasQuery } from "@/redux/api/master/location/areaApi";

export const useLocationOptions = ({
  selectedCountry,
  selectedState,
  selectedCity,
}: {
  selectedCountry?: string;
  selectedState?: string;
  selectedCity?: string;
} = {}) => {
  // Countries
  const { data: countryData, isLoading: loadingCountries } =
    useGetCountriesQuery({ page: -1, sortBy: "name:asc" });
  const countryOptions =
    countryData?.data?.results?.map((country) => ({
      label: country.name,
      value: country.id,
    })) || [];

  // States (filtered if selectedCountry passed, otherwise all)
  const {
    data: stateData,
    isLoading: loadingStates,
    refetch: refetchStates,
  } = useGetStatesQuery({
    page: -1,
    sortBy: "name:asc",
    ...(selectedCountry ? { country: selectedCountry } : {}),
  });
  const stateOptions =
    stateData?.data?.results?.map((state) => ({
      label: state.name,
      value: state.id,
    })) || [];

  // Cities (filtered if selectedState passed, otherwise all)
  const {
    data: cityData,
    isLoading: loadingCities,
    refetch: refetchCities,
  } = useGetCitiesQuery({
    page: -1,
    sortBy: "name:asc",
    ...(selectedState ? { state: selectedState } : {}),
  });
  const cityOptions =
    cityData?.data?.results?.map((city) => ({
      label: city.name,
      value: city.id,
    })) || [];

  // Areas (filtered if selectedCity passed, otherwise all)
  const {
    data: areaData,
    isLoading: loadingAreas,
    refetch: refetchAreas,
  } = useGetAreasQuery({
    page: 1,
    limit: 10,
    sortBy: "name:asc",
    ...(selectedCity ? { city: selectedCity } : {}),
  });
  const areaOptions =
    areaData?.data?.results?.map((area) => {
      const [longitude, latitude] = area.loc.coordinates;
      return {
        label: area.name,
        value: area.id,
        latitude,
        longitude,
        pinCode: area.pinCode,
      };
    }) || [];

  const areaCoordinatesMap =
    areaData?.data?.results?.reduce((acc, area) => {
      const [longitude, latitude] = area.loc.coordinates;
      acc[area.id] = { latitude, longitude };
      return acc;
    }, {} as Record<string, { latitude: number; longitude: number }>) || {};

  const areaPinCodesMap =
    areaData?.data?.results?.reduce((acc, area) => {
      acc[area.id] = area.pinCode;
      return acc;
    }, {} as Record<string, number[]>) || {};

  return {
    countryOptions,
    stateOptions,
    cityOptions,
    areaOptions,
    areaPinCodesMap,
    areaCoordinatesMap,
    isLoading: {
      countries: loadingCountries,
      states: loadingStates,
      cities: loadingCities,
      areas: loadingAreas,
    },
    refetch: {
      states: refetchStates,
      cities: refetchCities,
      areas: refetchAreas,
    },
  };
};