import { initialUsers, userType } from "@/constants";
import {
  useGetCompaniesQuery,
  useGetCompanyByIdQuery,
} from "@/redux/api/companyApi";
import { useGetIndividualPropertiesQuery } from "@/redux/api/individualProperties";
import { useGetLeadsQuery } from "@/redux/api/leadApi";
import { useGetAmenitiesQuery } from "@/redux/api/master/constructionStatus/amenitiesApi";
import { useGetTagsQuery } from "@/redux/api/master/constructionStatus/tagsApi";
import { useGetLeadStagesQuery } from "@/redux/api/master/leadStageMaster/leadStageMasterApi";
import { useGetCategoriesQuery } from "@/redux/api/master/property/categoryApi";
import { useGetPropertyConfigurationsQuery } from "@/redux/api/master/property/configurationApi";
import { useGetSubCategoriesQuery } from "@/redux/api/master/property/subCategoryApi";
import { useGetProjectsQuery } from "@/redux/api/projectApi";
import { useGetRolesQuery } from "@/redux/api/roleApi";
import { useGetTeamsQuery } from "@/redux/api/teamApi";
import { useGetUsersQuery } from "@/redux/api/userApi";
import { initialBankAccounts, users } from "@/utils/data";
import { generateOptions } from "@/utils/generateOptions";
import { useSession } from "next-auth/react";

export const useOptions = (
  requiredOptions: string[] = [],
  search?: string,
  selectedPropertyType?: string,
  selectedSubCategory?: string,
) => {
  const { data: session } = useSession();

  // Always fetch company data as it seems to be needed for credits
  const { data: companiesData } = useGetCompanyByIdQuery(
    session?.companyId as string,
    {
      skip: !session?.companyId,
    },
  );

  const {
    emailCredit = 0,
    smsCredit = 0,
    whatsAppCredit = 0,
  } = companiesData?.data || {};

  // Conditional API calls based on requiredOptions
  const { data: categories, isLoading: loadingCategories } =
    useGetCategoriesQuery(
      {
        page: -1,
        sortBy: "name:asc",
        ...(search && { search }),
      },
      {
        skip: !requiredOptions.includes("categories"),
      },
    );
  const categoriesData = categories?.data.results || [];

  const { data: subCategories, isLoading: loadingSubCategories } =
    useGetSubCategoriesQuery(
      {
        page: -1,
        sortBy: "name:asc",
        ...(selectedPropertyType && { categoryId: selectedPropertyType }),
        ...(search && { search }),
      },
      {
        skip: !requiredOptions.includes("subCategories"),
      },
    );
  const subCategoriesData = subCategories?.data.results || [];

  const { data: roles } = useGetRolesQuery(
    {
      // page: -1,
      sortBy: "name:asc",
      ...(search && { search }),
    },
    {
      skip: !requiredOptions.includes("roles"),
    },
  );
  const rolesData = roles?.data.results || [];

  const { data: teams } = useGetTeamsQuery(
    {
      // page: -1,
      sortBy: "name:asc",
      companyId: session?.companyId,
      ...(search && { search }),
    },
    {
      skip: !requiredOptions.includes("teams"),
    },
  );
  const teamsData = teams?.data.results || [];
  const teamsCount = teams?.data?.totalResults || 0;

  const { data: usersData } = useGetUsersQuery(
    {
      page: -1,
      sortBy: "name:asc",
      company: session?.companyId,
      status: "active",
      ...(search && { search }),
    },
    {
      skip: !requiredOptions.includes("users"),
    },
  );
  const usersCount = usersData?.data?.totalResults || 0;

  const userOptions =
    usersData?.data?.results?.map((user) => ({
      label: user.firstName + " " + user.lastName,
      value: String(user.id),
    })) || [];

  const { data: company } = useGetCompaniesQuery(
    {
      // page: -1,
      sortBy: "name:asc",
      status: "active",
      ...(search && { search }),
    },
    {
      skip: !requiredOptions.includes("companies"),
    },
  );
  const companyData = company?.data.results || [];

  const { data: brokercompany } = useGetCompaniesQuery(
    {
      // page: -1,
      sortBy: "name:asc",
      status: "active",
      companyType: "broker",
      ...(search && { search }),
    },
    {
      skip: !requiredOptions.includes("brokerCompanies"),
    },
  );
  const brokerCompanyData = brokercompany?.data.results || [];

  const { data: buildercompany } = useGetCompaniesQuery(
    {
      // page: -1,
      sortBy: "name:asc",
      status: "active",
      companyType: "builder",
      ...(search && { search }),
    },
    {
      skip: !requiredOptions.includes("builderCompanies"),
    },
  );
  const builderCompanyData = buildercompany?.data.results || [];

  const { data: leadsData } = useGetLeadsQuery(
    {
      // page: -1,
      populate:
        "leadStage:stageName,id,color; contact:id,firstName,lastName,name,primaryPhone,phone,email,companyName; assignedTo:id,firstName,lastName; company:id,name,companyType",
      alias:
        "contact.primaryPhone:phoneNumber;contact.name:name;leadStage.stageName:leadStageName; contact.email:email",
      includeTimeStamps: true,
      ...(session?.role !== "superAdmin" && { company: session?.companyId }),
      ...(search && { search }),
    },
    {
      skip: !requiredOptions.includes("leads"),
    },
  );

  const { data: projectData } = useGetProjectsQuery(
    {
      page: -1,
      isViewOnly: true,
      populate: "locality:name;city:name;state:name",
      companyId: session?.companyId,
      ...(search && { search }),
    },
    {
      skip: !requiredOptions.includes("projects"),
    },
  );

  const { data: propertyData } = useGetIndividualPropertiesQuery(
    {
      page: -1,
      companyId: session?.companyId,
      populate:
        "propertyType:name;locality:name;city:name;createdBy:firstName,lastName,email;project:id,projectName;companyId:name",
    },
    {
      skip: !requiredOptions.includes("properties"),
    },
  );

  const propertyOptions =
    propertyData?.data?.results?.map((property) => ({
      label: property.title,
      value: property.id,
    })) || [];

  const projectOptions =
    projectData?.data?.results?.map((project) => {
      const rawCity = project.city?.name;
      const rawState = (project as any).state?.name;
      const toTitle = (s?: string | null) =>
        s
          ? s.toString().charAt(0).toUpperCase() +
            s.toString().slice(1).toLowerCase()
          : "";
      const city = toTitle(rawCity);
      const state = toTitle(rawState);
      const location =
        [city, state].filter(Boolean).join(", ") || city || state || "";
      return {
        label: location
          ? `${project.projectName} - ${location}`
          : project.projectName,
        value: project.id,
      };
    }) || [];

  const { data: leadStageData } = useGetLeadStagesQuery({
    page: -1,
    alias: "stageName:name",
    sortBy: "position:asc",
    ...(session?.companyId && {
      company: session?.companyId,
    }),
    ...(search && { search }),
  });

  const leadStageOptions = generateOptions(leadStageData?.data.results || []);

  const companyNameOptions =
    leadsData?.data?.results
      ?.flatMap((lead) => lead?.contact?.companyName || [])
      ?.filter((name, index, self) => name && self.indexOf(name) === index)
      ?.map((name) => ({ label: name, value: name })) || [];

  const { data: amenitiesData } = useGetAmenitiesQuery({ page: -1 });

  const amenityOptions = generateOptions(amenitiesData?.data.results || []);

  const { data: tagsData } = useGetTagsQuery({ page: -1 });

  const tagOptions = generateOptions(tagsData?.data.results || []);

  const { data: configurationData } = useGetPropertyConfigurationsQuery(
    {
      page: -1,
      categoryId: selectedPropertyType,
      subCategoryId: selectedSubCategory,
    },
    {
      skip: !(selectedPropertyType && selectedSubCategory),
    },
  );

  const configurationOptions = generateOptions(
    configurationData?.data?.results || [],
  );

  const roleOptions = generateOptions(rolesData);
  const categoryOptions = generateOptions(categoriesData);
  const subCategoryOptions = generateOptions(subCategoriesData);
  const companyOptions = generateOptions(companyData);
  const brokerCompanyOptions = generateOptions(brokerCompanyData);
  const builderCompanyOptions = generateOptions(builderCompanyData);
  const teamOptions = generateOptions(teamsData);
  const userOptionsAvatar = generateOptions(initialUsers, {
    extraKeys: ["avatar"],
  });
  const userTypeOptions = generateOptions(userType);
  const bankNameOptions = generateOptions(initialBankAccounts, {
    useDefaults: false,
    valueKey: "bankName",
    labelKey: "bankName",
  });
  const companyUserOptions =
    usersData?.data?.results?.map((user) => ({
      label: user.firstName + " " + user.lastName,
      value: user.id.toString(),
    })) || [];

  return {
    roleOptions,
    teamOptions,
    teamsData,
    userOptionsAvatar,
    userOptions,
    userTypeOptions,
    bankNameOptions,
    categoryOptions,
    companyOptions,
    companyData,
    teamsCount,
    usersCount,
    companyNameOptions,
    projectOptions,
    projectData,
    companyUserOptions,
    propertyOptions,
    emailCredit,
    smsCredit,
    whatsAppCredit,
    propertyData,
    leadStageOptions,
    subCategoryOptions,
    brokerCompanyOptions,
    builderCompanyOptions,
    amenityOptions,
    tagOptions,
    configurationOptions,
  };
};