import { useState, useCallback } from "react";
import { getProxyBaseUrl, getGlobalLitellmHeaderName } from "@/components/networking";
import NotificationsManager from "../molecules/notifications_manager";
import { DiscountConfig } from "./types";
import { getProviderBackendValue } from "./provider_display_helpers";
import { Providers } from "../provider_info_helpers";

export interface UseDiscountConfigProps {
  accessToken: string | null;
}

export interface UseDiscountConfigReturn {
  discountConfig: DiscountConfig;
  setDiscountConfig: React.Dispatch<React.SetStateAction<DiscountConfig>>;
  fetchDiscountConfig: () => Promise<void>;
  saveDiscountConfig: (config: DiscountConfig) => Promise<void>;
  handleAddProvider: (selectedProvider: string | undefined, newDiscount: string) => Promise<boolean>;
  handleRemoveProvider: (provider: string) => Promise<void>;
  handleDiscountChange: (provider: string, value: string) => Promise<void>;
}

export function useDiscountConfig({ accessToken }: UseDiscountConfigProps): UseDiscountConfigReturn {
  const [discountConfig, setDiscountConfig] = useState<DiscountConfig>({});

  const fetchDiscountConfig = useCallback(async () => {
    try {
      const proxyBaseUrl = getProxyBaseUrl();
      const url = proxyBaseUrl ? `${proxyBaseUrl}/config/cost_discount_config` : "/config/cost_discount_config";

      const response = await fetch(url, {
        method: "GET",
        headers: {
          [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
          "Content-Type": "application/json",
        },
      });

      if (response.ok) {
        const data = await response.json();
        setDiscountConfig(data.values || {});
      } else {
        console.error("Failed to fetch discount config");
      }
    } catch (error) {
      console.error("Error fetching discount config:", error);
      NotificationsManager.fromBackend("Failed to fetch discount configuration");
    }
  }, [accessToken]);

  const saveDiscountConfig = useCallback(
    async (config: DiscountConfig) => {
      try {
        const proxyBaseUrl = getProxyBaseUrl();
        const url = proxyBaseUrl ? `${proxyBaseUrl}/config/cost_discount_config` : "/config/cost_discount_config";

        const response = await fetch(url, {
          method: "PATCH",
          headers: {
            [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
            "Content-Type": "application/json",
          },
          body: JSON.stringify(config),
        });

        if (response.ok) {
          NotificationsManager.success("Discount configuration updated successfully");
          await fetchDiscountConfig();
        } else {
          const errorData = await response.json();
          const errorMessage = errorData.detail?.error || errorData.detail || "Failed to update settings";
          NotificationsManager.fromBackend(errorMessage);
        }
      } catch (error) {
        console.error("Error updating discount config:", error);
        NotificationsManager.fromBackend("Failed to update discount configuration");
      }
    },
    [accessToken, fetchDiscountConfig],
  );

  const handleAddProvider = useCallback(
    async (selectedProvider: string | undefined, newDiscount: string): Promise<boolean> => {
      if (!selectedProvider || !newDiscount) {
        NotificationsManager.fromBackend("Please select a provider and enter discount percentage");
        return false;
      }

      const percentageValue = parseFloat(newDiscount);
      if (isNaN(percentageValue) || percentageValue < 0 || percentageValue > 100) {
        NotificationsManager.fromBackend("Discount must be between 0% and 100%");
        return false;
      }

      const providerValue = getProviderBackendValue(selectedProvider);

      if (!providerValue) {
        NotificationsManager.fromBackend("Invalid provider selected");
        return false;
      }

      if (discountConfig[providerValue]) {
        NotificationsManager.fromBackend(
          `Discount for ${Providers[selectedProvider as keyof typeof Providers]} already exists. Edit it in the table above.`,
        );
        return false;
      }

      const discountValue = percentageValue / 100;
      const updatedConfig = {
        ...discountConfig,
        [providerValue]: discountValue,
      };

      setDiscountConfig(updatedConfig);
      await saveDiscountConfig(updatedConfig);
      return true;
    },
    [discountConfig, saveDiscountConfig],
  );

  const handleRemoveProvider = useCallback(
    async (provider: string) => {
      const updatedConfig = { ...discountConfig };
      delete updatedConfig[provider];
      setDiscountConfig(updatedConfig);
      await saveDiscountConfig(updatedConfig);
    },
    [discountConfig, saveDiscountConfig],
  );

  const handleDiscountChange = useCallback(
    async (provider: string, value: string) => {
      const discountValue = parseFloat(value);
      if (!isNaN(discountValue) && discountValue >= 0 && discountValue <= 1) {
        const updatedConfig = {
          ...discountConfig,
          [provider]: discountValue,
        };
        setDiscountConfig(updatedConfig);
        await saveDiscountConfig(updatedConfig);
      }
    },
    [discountConfig, saveDiscountConfig],
  );

  return {
    discountConfig,
    setDiscountConfig,
    fetchDiscountConfig,
    saveDiscountConfig,
    handleAddProvider,
    handleRemoveProvider,
    handleDiscountChange,
  };
}
