import { useCallback, useEffect, useState } from 'react';
import axios from 'axios';
import { t } from '@lingui/macro';
import { useLingui } from '@lingui/react';
import { useToast } from '../components/shared/ToastProvider';
import { extractErrorMessage } from '../utils/errorHandler';
import type { Becken } from '../types/class';

export interface UseBeckenReturn {
  becken: Becken[];
  loading: boolean;
  error: string | null;
  reload: () => Promise<void>;
  save: (payload: Partial<Becken> & { zb_name: string }) => Promise<Becken | null>;
  remove: (id: number) => Promise<boolean>;
}

export function useBecken(berId: number | ''): UseBeckenReturn {
  const { i18n } = useLingui();
  const toast = useToast();
  const [becken, setBecken] = useState<Becken[]>([]);
  const [loading, setLoading] = useState<boolean>(false);
  const [error, setError] = useState<string | null>(null);

  const reload = useCallback(async (): Promise<void> => {
    if (berId === '' || berId === null || berId === undefined) {
      setBecken([]);
      return;
    }
    try {
      setLoading(true);
      setError(null);
      const response = await axios.get('/zeiterfassung/becken', {
        params: { ber_id: berId },
      });
      setBecken(Array.isArray(response.data) ? response.data : []);
    } catch (err) {
      const message: string = extractErrorMessage(err);
      setError(message);
      toast.error({
        title: i18n._(t`Fehler beim Laden der Becken`),
        description: message,
      });
    } finally {
      setLoading(false);
    }
  }, [berId, i18n, toast]);

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

  const save = useCallback(
    async (payload: Partial<Becken> & { zb_name: string }): Promise<Becken | null> => {
      if (berId === '' || berId === null || berId === undefined) {
        return null;
      }
      try {
        const body: Record<string, unknown> = {
          ber_id: berId,
          zb_name: payload.zb_name,
          zb_short_code: payload.zb_short_code ?? null,
          zb_color: payload.zb_color ?? null,
          zb_gps_lat: payload.zb_gps_lat ?? null,
          zb_gps_lng: payload.zb_gps_lng ?? null,
          zb_active: payload.zb_active ?? true,
        };
        let saved: Becken;
        if (payload.zb_id) {
          const response = await axios.put(`/zeiterfassung/becken/${payload.zb_id}`, body);
          saved = response.data as Becken;
        } else {
          const response = await axios.post('/zeiterfassung/becken', body);
          saved = response.data as Becken;
        }
        toast.success({ title: i18n._(t`Becken gespeichert`) });
        await reload();
        return saved;
      } catch (err) {
        const message: string = extractErrorMessage(err);
        toast.error({
          title: i18n._(t`Fehler beim Speichern`),
          description: message,
        });
        return null;
      }
    },
    [berId, i18n, reload, toast]
  );

  const remove = useCallback(
    async (id: number): Promise<boolean> => {
      try {
        await axios.delete(`/zeiterfassung/becken/${id}`);
        toast.success({ title: i18n._(t`Becken gelöscht`) });
        await reload();
        return true;
      } catch (err) {
        const message: string = extractErrorMessage(err);
        toast.error({
          title: i18n._(t`Fehler beim Löschen`),
          description: message,
        });
        return false;
      }
    },
    [i18n, reload, toast]
  );

  return { becken, loading, error, reload, save, remove };
}

export default useBecken;