import { useCallback, useEffect, useRef, useState } from 'react';
import { useTrans } from '@rutatiina/ui/lib/translations';
import { useLeaveGuard } from '@rutatiina/ui/hooks/use-leave-guard';
import {
  applicationJson,
  ApplicationHttpError,
  type ApplicationValues,
  type Draft,
} from '@nugsoft/loans/lib/application';

/** Serialize autosaves, including Save and exit, so slow responses cannot overwrite newer input. */
export function useApplicationDraft(
  uuid: string,
  values: ApplicationValues,
  step: number,
  initial: Draft | null,
) {
  const __ = useTrans();
  const [status, setStatus] = useState<
    'unsaved' | 'saving' | 'saved' | 'error'
  >(initial ? 'saved' : 'unsaved');
  const [error, setError] = useState('');
  const [conflict, setConflict] = useState(false);
  const [reference, setReference] = useState(initial?.reference ?? '');
  const latest = useRef({ data: values, step });
  const version = useRef(initial?.version ?? 0);
  const saved = useRef(
    initial ? JSON.stringify({ data: initial.data, step: initial.step }) : '',
  );
  const queue = useRef<Promise<void>>(Promise.resolve());
  const blocked = useRef(false);
  const leaving = useRef(false);
  const mounted = useRef(true);

  const save = useCallback(async () => {
    const task = queue.current
      .catch(() => {})
      .then(async () => {
        if (blocked.current)
          throw new Error(__('Reload the saved draft before continuing.'));
        const snapshot = latest.current;
        const fingerprint = JSON.stringify(snapshot);
        if (fingerprint === saved.current) return;
        if (mounted.current) {
          setStatus('saving');
          setError('');
        }
        try {
          const draft = await applicationJson<Draft>(
            `/loans/application-drafts/${uuid}`,
            'PUT',
            { ...snapshot, version: version.current },
          );
          version.current = draft.version;
          saved.current = fingerprint;
          if (mounted.current) {
            setReference(draft.reference);
            setStatus(
              JSON.stringify(latest.current) === fingerprint
                ? 'saved'
                : 'unsaved',
            );
          }
        } catch (reason) {
          if (reason instanceof ApplicationHttpError && reason.status === 409) {
            blocked.current = true;
            if (mounted.current) setConflict(true);
          }
          if (mounted.current) {
            setStatus('error');
            setError(
              reason instanceof Error
                ? reason.message
                : __('The draft could not be saved. Please retry.'),
            );
          }
          throw reason;
        }
      });
    queue.current = task;
    await task;
    return version.current;
  }, [uuid, __]);

  useEffect(() => {
    latest.current = { data: values, step };
    if (JSON.stringify(latest.current) === saved.current) return;
    setStatus('unsaved');
    const timer = window.setTimeout(() => {
      void save().catch(() => {});
    }, 1000);
    return () => window.clearTimeout(timer);
  }, [values, step, save]);

  useEffect(() => {
    mounted.current = true;
    return () => {
      mounted.current = false;
    };
  }, []);
  useLeaveGuard({
    title: __('Leave this loan application?'),
    description: __('Your latest changes have not been saved yet.'),
    confirmLabel: __('Leave anyway'),
    cancelLabel: __('Stay'),
    destructive: true,
    when: () =>
      !leaving.current && JSON.stringify(latest.current) !== saved.current,
  });

  return {
    status,
    error,
    conflict,
    reference,
    save,
    allowExit: () => {
      leaving.current = true;
    },
  };
}
