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 { ClassTemplate, RegenerateResult } from '../types/class';

export interface UseClassTemplatesReturn {
  templates: ClassTemplate[];
  loading: boolean;
  error: string | null;
  reload: () => Promise<void>;
  save: (tpl: Partial<ClassTemplate>) => Promise<ClassTemplate | null>;
  remove: (id: number) => Promise<boolean>;
  regenerate: (id: number) => Promise<RegenerateResult | null>;
}

export function useClassTemplates(berId: number | ''): UseClassTemplatesReturn {
  const { i18n } = useLingui();
  const toast = useToast();
  const [templates, setTemplates] = useState<ClassTemplate[]>([]);
  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) {
      setTemplates([]);
      return;
    }
    try {
      setLoading(true);
      setError(null);
      const response = await axios.get('/zeiterfassung/class-templates', {
        params: { ber_id: berId },
      });
      setTemplates(Array.isArray(response.data) ? response.data : []);
    } catch (err) {
      const message: string = extractErrorMessage(err);
      setError(message);
      toast.error({
        title: i18n._(t`Fehler beim Laden der Klassenvorlagen`),
        description: message,
      });
    } finally {
      setLoading(false);
    }
  }, [berId, i18n, toast]);

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

  const save = useCallback(
    async (tpl: Partial<ClassTemplate>): Promise<ClassTemplate | null> => {
      if (berId === '' || berId === null || berId === undefined) {
        return null;
      }
      try {
        const body: Record<string, unknown> = {
          zct_ber_id: berId,
          zct_becken_id: tpl.zct_becken_id,
          zct_required_role_id: tpl.zct_required_role_id,
          zct_name: tpl.zct_name,
          zct_description: tpl.zct_description ?? null,
          zct_color: tpl.zct_color ?? null,
          zct_capacity: tpl.zct_capacity ?? null,
          zct_valid_from: tpl.zct_valid_from,
          zct_valid_to: tpl.zct_valid_to,
          zct_priority: tpl.zct_priority ?? 0,
          zct_holiday_mode: tpl.zct_holiday_mode ?? false,
          zct_parent_template_id: tpl.zct_parent_template_id ?? null,
          zct_active: tpl.zct_active ?? true,
          schedules: tpl.schedules ?? [],
        };
        let response;
        if (tpl.zct_id) {
          response = await axios.put(`/zeiterfassung/class-templates/${tpl.zct_id}`, body);
        } else {
          response = await axios.post('/zeiterfassung/class-templates', body);
        }
        const saved: ClassTemplate = (response.data?.template as ClassTemplate) ?? (response.data as ClassTemplate);
        toast.success({ title: i18n._(t`Klassenvorlage gespeichert`) });
        await reload();
        return saved;
      } catch (err) {
        const message: string = extractErrorMessage(err);
        toast.error({
          title: i18n._(t`Fehler beim Speichern`),
          description: message,
        });
        throw err;
      }
    },
    [berId, i18n, reload, toast]
  );

  const remove = useCallback(
    async (id: number): Promise<boolean> => {
      try {
        await axios.delete(`/zeiterfassung/class-templates/${id}`);
        toast.success({ title: i18n._(t`Klassenvorlage 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]
  );

  const regenerate = useCallback(
    async (id: number): Promise<RegenerateResult | null> => {
      try {
        const response = await axios.post(`/zeiterfassung/class-templates/${id}/regenerate`);
        const result: RegenerateResult = (response.data?.regenerated as RegenerateResult) ?? (response.data as RegenerateResult);
        toast.success({ title: i18n._(t`Sitzungen neu generiert`) });
        await reload();
        return result;
      } catch (err) {
        const message: string = extractErrorMessage(err);
        toast.error({
          title: i18n._(t`Fehler bei der Regenerierung`),
          description: message,
        });
        return null;
      }
    },
    [i18n, reload, toast]
  );

  return { templates, loading, error, reload, save, remove, regenerate };
}

export default useClassTemplates;