import { useState, useEffect, useCallback } from 'react';
import axios from 'axios';
import { t } from '@lingui/macro';
import { useLingui } from '@lingui/react';

export interface BreakRule {
  min_work_hours: number;
  max_work_hours: number;
  required_break_minutes: number;
  description?: string;
}

export interface CompanySettings {
  zcs_id: number;
  zcs_mandatory_rest_hours: number;
  zcs_max_consecutive_days: number;
  zcs_min_shift_hours: number;
  zcs_max_shift_hours: number;
  zcs_max_hours_per_week: number;
  zcs_max_hours_per_day: number;
  zcs_max_work_hours_per_day: number;
  zcs_max_continuous_work_hours: number;
  zcs_disable_arbzg_checking: boolean;
  zcs_break_rules: BreakRule[];
  zcs_min_days_advance_notice: number;
  zcs_allow_overtime: boolean;
  zcs_overtime_threshold: number;
  zcs_require_weekend_rest: boolean;
  zcs_min_sundays_off_per_month: number;
  zcs_notify_on_assignment: boolean;
  zcs_notify_on_change: boolean;
  zcs_reminder_hours_before: number;
  zcs_nfc_enabled: boolean;
  zcs_nfc_chips: string[] | null;
  zcs_time_report_email: string | null;
  zcs_time_report_enabled: boolean;
  zcs_time_report_emails: string[] | null;
  zcs_time_report_send_day_type: 'last_day' | 'last_business_day' | 'specific_day';
  zcs_time_report_send_day: number | null;
  zcs_time_report_send_to_users: boolean;
  zcs_active: boolean;
  zcs_reset_overtime_annually: boolean;
  zcs_overtime_carry_over: boolean;
  zcs_last_overtime_reset_date: string | null;
  zcs_sick_days_until_au_required: number;
  zcs_clock_in_only_within_shift: boolean;
}

export interface UseCompanySettingsReturn {
  settings: CompanySettings | null;
  loading: boolean;
  saving: boolean;
  successMessage: string;
  errorMessage: string;
  validationWarnings: string[];
  isGerman: boolean;
  getUnit: (type: 'hours' | 'days' | 'minutes') => string;
  handleChange: (field: keyof CompanySettings, value: any) => void;
  handleSave: () => Promise<void>;
  handleReset: () => Promise<void>;
  handleDisableArbzgToggle: () => Promise<void>;
  handleConfirmDisableArbzg: () => Promise<void>;
  disableArbzgDialogOpen: boolean;
  setDisableArbzgDialogOpen: (open: boolean) => void;
  setSuccessMessage: (msg: string) => void;
  setErrorMessage: (msg: string) => void;
}

interface UseCompanySettingsOptions {
  confirm: (options: { title: string; message: string; color?: 'error' | 'primary' | 'warning' }) => Promise<boolean>;
}

export function useCompanySettings(options: UseCompanySettingsOptions): UseCompanySettingsReturn {
  const { confirm } = options;
  const { i18n } = useLingui();
  const [settings, setSettings] = useState<CompanySettings | null>(null);
  const [loading, setLoading] = useState(true);
  const [saving, setSaving] = useState(false);
  const [successMessage, setSuccessMessage] = useState('');
  const [errorMessage, setErrorMessage] = useState('');
  const [validationWarnings, setValidationWarnings] = useState<string[]>([]);
  const [disableArbzgDialogOpen, setDisableArbzgDialogOpen] = useState(false);

  const isGerman = i18n.locale?.startsWith('de') ?? true;

  const getUnit = useCallback(
    (type: 'hours' | 'days' | 'minutes'): string => {
      switch (type) {
        case 'hours':
          return isGerman ? 'Std' : 'h';
        case 'days':
          return isGerman ? 'Tage' : 'd';
        case 'minutes':
          return isGerman ? 'Min' : 'min';
      }
    },
    [isGerman]
  );

  const validateArbZGCompliance = useCallback(
    (updatedSettings: CompanySettings): string[] => {
      if (updatedSettings.zcs_disable_arbzg_checking) {
        return [];
      }

      const warnings: string[] = [];

      if (updatedSettings.zcs_max_continuous_work_hours > 6) {
        warnings.push(
          i18n._(
            t`Warnung: Maximale durchgehende Arbeitszeit sollte 6 Stunden nicht überschreiten (ArbZG §4)`
          )
        );
      }

      if (updatedSettings.zcs_max_work_hours_per_day > 10) {
        warnings.push(
          i18n._(
            t`Warnung: Maximale Arbeitszeit pro Tag sollte 10 Stunden nicht überschreiten (ArbZG §3)`
          )
        );
      }

      if (updatedSettings.zcs_max_shift_hours > 10.75) {
        warnings.push(
          i18n._(
            t`Warnung: Maximale Schichtdauer sollte 10,75 Stunden nicht überschreiten (10h Arbeit + 45min Pause)`
          )
        );
      }

      if (
        updatedSettings.zcs_max_continuous_work_hours >= updatedSettings.zcs_max_work_hours_per_day
      ) {
        warnings.push(
          i18n._(
            t`Warnung: Maximale durchgehende Arbeitszeit sollte kleiner sein als maximale Arbeitszeit pro Tag`
          )
        );
      }

      return warnings;
    },
    [i18n]
  );

  const fetchSettings = useCallback(async () => {
    try {
      setLoading(true);
      const response = await axios.get('/zeiterfassung/company-settings');
      setSettings(response.data);
      const warnings = validateArbZGCompliance(response.data);
      setValidationWarnings(warnings);
    } catch (error) {
      console.error('Error fetching company settings:', error);
    } finally {
      setLoading(false);
    }
  }, [validateArbZGCompliance]);

  useEffect(() => {
    fetchSettings();
  }, [fetchSettings]);

  const handleSave = useCallback(async () => {
    if (!settings) return;

    try {
      setSaving(true);
      await axios.put('/zeiterfassung/company-settings', settings);
      setErrorMessage('');
      setSuccessMessage(i18n._(t`Einstellungen erfolgreich gespeichert`));
      setTimeout(() => setSuccessMessage(''), 3000);
    } catch (error) {
      console.error('Error saving company settings:', error);
      setErrorMessage(i18n._(t`Fehler beim Speichern der Einstellungen`));
    } finally {
      setSaving(false);
    }
  }, [settings, i18n]);

  const handleReset = useCallback(async () => {
    const confirmed = await confirm({
      title: i18n._(t`Einstellungen zurücksetzen`),
      message: i18n._(t`Möchten Sie die Einstellungen wirklich auf die Standardwerte zurücksetzen?`),
      color: 'warning',
    });
    if (!confirmed) {
      return;
    }

    try {
      setSaving(true);
      const response = await axios.post('/zeiterfassung/company-settings/reset');
      setSettings(response.data.settings);
      setErrorMessage('');
      setSuccessMessage(i18n._(t`Einstellungen auf Standardwerte zurückgesetzt`));
      setTimeout(() => setSuccessMessage(''), 3000);
      const warnings = validateArbZGCompliance(response.data.settings);
      setValidationWarnings(warnings);
    } catch (error) {
      console.error('Error resetting company settings:', error);
      setErrorMessage(i18n._(t`Fehler beim Zurücksetzen der Einstellungen`));
    } finally {
      setSaving(false);
    }
  }, [confirm, i18n, validateArbZGCompliance]);

  const handleChange = useCallback(
    (field: keyof CompanySettings, value: any) => {
      if (!settings) return;
      const updatedSettings = { ...settings, [field]: value };
      setSettings(updatedSettings);

      if (
        [
          'zcs_max_work_hours_per_day',
          'zcs_max_continuous_work_hours',
          'zcs_max_shift_hours',
          'zcs_disable_arbzg_checking',
        ].includes(field)
      ) {
        const warnings = validateArbZGCompliance(updatedSettings);
        setValidationWarnings(warnings);
      }
    },
    [settings, validateArbZGCompliance]
  );

  const handleDisableArbzgToggle = useCallback(async () => {
    if (!settings) return;

    if (settings.zcs_disable_arbzg_checking) {
      const updatedSettings = { ...settings, zcs_disable_arbzg_checking: false };
      setSettings(updatedSettings);

      const warnings = validateArbZGCompliance(updatedSettings);
      setValidationWarnings(warnings);

      try {
        setSaving(true);
        await axios.put('/zeiterfassung/company-settings', updatedSettings);
        setErrorMessage('');
        setSuccessMessage(i18n._(t`ArbZG-Überprüfung aktiviert`));
        setTimeout(() => setSuccessMessage(''), 3000);
      } catch (error) {
        console.error('Error saving settings:', error);
        setErrorMessage(i18n._(t`Fehler beim Speichern der Einstellungen`));
        setSettings(settings);
      } finally {
        setSaving(false);
      }
    } else {
      setDisableArbzgDialogOpen(true);
    }
  }, [settings, i18n, validateArbZGCompliance]);

  const handleConfirmDisableArbzg = useCallback(async () => {
    if (!settings) return;

    const updatedSettings = { ...settings, zcs_disable_arbzg_checking: true };
    setSettings(updatedSettings);
    setDisableArbzgDialogOpen(false);

    setValidationWarnings([]);

    try {
      setSaving(true);
      await axios.put('/zeiterfassung/company-settings', updatedSettings);
      setErrorMessage('');
      setSuccessMessage(i18n._(t`ArbZG-Überprüfung deaktiviert`));
      setTimeout(() => setSuccessMessage(''), 3000);
    } catch (error) {
      console.error('Error saving settings:', error);
      setErrorMessage(i18n._(t`Fehler beim Speichern der Einstellungen`));
      setSettings(settings);
      const warnings = validateArbZGCompliance(settings);
      setValidationWarnings(warnings);
    } finally {
      setSaving(false);
    }
  }, [settings, i18n, validateArbZGCompliance]);

  return {
    settings,
    loading,
    saving,
    successMessage,
    errorMessage,
    validationWarnings,
    isGerman,
    getUnit,
    handleChange,
    handleSave,
    handleReset,
    handleDisableArbzgToggle,
    handleConfirmDisableArbzg,
    disableArbzgDialogOpen,
    setDisableArbzgDialogOpen,
    setSuccessMessage,
    setErrorMessage,
  };
}

export default useCompanySettings;