import { useState, useEffect, useCallback } from "react";
import useCompanySettingsService from "./useCompanySettingsService";
import {
  type CompanySettings,
  type UpdateCompanySettingsPayload,
} from "../../services/companySettingsService";

interface UseCompanySettingsState {
  settings: CompanySettings | null;
  loading: boolean;
  error: string | null;
  hasChanges: boolean;
}

interface UseCompanySettingsActions {
  fetchSettings: () => void;
  updateSettings: (data: UpdateCompanySettingsPayload) => Promise<boolean>;
  resetChanges: () => void;
}

const INITIAL_STATE: UseCompanySettingsState = {
  settings: null,
  loading: false,
  error: null,
  hasChanges: false,
};

function useCompanySettings() {
  const [state, setState] = useState<UseCompanySettingsState>(INITIAL_STATE);
  const [originalSettings, setOriginalSettings] = useState<CompanySettings | null>(null);
  const service = useCompanySettingsService();

  // Fetch company settings
  const fetchSettings = useCallback(async () => {
    setState((prev) => ({ ...prev, loading: true, error: null }));

    const result = await service.getCompanySettings();

    if (result.success && result.data) {
      const settings = result.data.data;
      setState((prev) => ({
        ...prev,
        settings,
        loading: false,
        error: null,
        hasChanges: false,
      }));
      setOriginalSettings(settings);
    } else {
      setState((prev) => ({
        ...prev,
        settings: null,
        loading: false,
        error: result.message,
        hasChanges: false,
      }));
      setOriginalSettings(null);
    }
  }, [service]);

  // Auto-fetch on mount
  useEffect(() => {
    fetchSettings();
  }, []);

  // Update settings
  const updateSettings = useCallback(
    async (data: UpdateCompanySettingsPayload): Promise<boolean> => {
      const result = await service.updateCompanySettings(data);
      if (result.success) {
        // Update local state with new settings
        const updatedSettings = result.data?.data;
        if (updatedSettings) {
          setState((prev) => ({
            ...prev,
            settings: updatedSettings,
            hasChanges: false,
          }));
          setOriginalSettings(updatedSettings);
        }
      }
      return result.success;
    },
    [service]
  );

  // Reset changes
  const resetChanges = useCallback(() => {
    if (originalSettings) {
      setState((prev) => ({
        ...prev,
        settings: originalSettings,
        hasChanges: false,
      }));
    }
  }, [originalSettings]);

  // Check for changes when settings update
  const checkForChanges = useCallback(
    (newSettings: CompanySettings) => {
      if (!originalSettings) return false;

      return (
        newSettings.working_hours_per_day !== originalSettings.working_hours_per_day ||
        newSettings.working_days_per_month !== originalSettings.working_days_per_month ||
        newSettings.break_minutes_per_day !== originalSettings.break_minutes_per_day ||
        newSettings.notes !== originalSettings.notes ||
        newSettings.company_name !== originalSettings.company_name ||
        newSettings.website !== originalSettings.website ||
        newSettings.hr_email !== originalSettings.hr_email ||
        newSettings.address !== originalSettings.address ||
        newSettings.footer !== originalSettings.footer ||
        newSettings.logo !== originalSettings.logo
      );
    },
    [originalSettings]
  );

  // Update settings locally (for form changes)
  const updateLocalSettings = useCallback(
    (updates: Partial<CompanySettings>) => {
      setState((prev) => {
        if (!prev.settings) return prev;

        const newSettings = { ...prev.settings, ...updates };
        const hasChanges = checkForChanges(newSettings);

        return {
          ...prev,
          settings: newSettings,
          hasChanges,
        };
      });
    },
    [checkForChanges]
  );

  const actions: UseCompanySettingsActions = {
    fetchSettings,
    updateSettings,
    resetChanges,
  };

  return {
    ...state,
    loading: state.loading || service.loading,
    updateLocalSettings,
    ...actions,
  };
}

export default useCompanySettings;