'use client';

import { useCallback, useEffect, useRef, useState } from 'react';
import { useDispatch, useSelector } from 'react-redux';
import { useTranslation } from 'react-i18next';
import { RootState } from '@/store';
import { setValidation } from '@/store/slices/installation-slice';
import { InstallationRepository } from '@/repositories/teltoinstall/_index';
import { apiErrorMessage } from '@/utils/teltoinstall/_index';

const POLL_INTERVAL_MS = 3000;
const TIMEOUT_MS = 90_000;

export type RfidTestStatus = 'idle' | 'waiting' | 'read' | 'timeout';

/**
 * Test du lecteur RFID / iButton (informatif) : `start()` lance l'attente côté
 * serveur, puis on interroge en polling jusqu'au passage d'un badge (code iButton
 * brut reçu par Flespi après le lancement) ou jusqu'au délai d'attente.
 */
export function useRfidTest() {
  const { t } = useTranslation();
  const dispatch = useDispatch();
  const { installationId, validation } = useSelector((state: RootState) => state.installation);
  const [status, setStatus] = useState<RfidTestStatus>(validation.rfid_code ? 'read' : 'idle');
  const [code, setCode] = useState<string | null>(validation.rfid_code ?? null);
  const [readAt, setReadAt] = useState<string | null>(validation.rfid_read_at ?? null);
  const [error, setError] = useState<string | null>(null);
  const timer = useRef<ReturnType<typeof setTimeout> | null>(null);

  const stop = useCallback(() => {
    if (timer.current) clearTimeout(timer.current);
    timer.current = null;
  }, []);

  useEffect(() => stop, [stop]);

  const start = useCallback(async () => {
    if (!installationId) return;
    stop();
    setError(null);
    setCode(null);
    setReadAt(null);
    try {
      await InstallationRepository.startRfidTest(installationId);
    } catch (err) {
      setError(apiErrorMessage(err, t('errors.generic')));
      setStatus('idle');
      return;
    }
    setStatus('waiting');
    const deadline = Date.now() + TIMEOUT_MS;

    async function poll() {
      try {
        const next = await InstallationRepository.pollRfidTest(installationId as number);
        if (next?.rfid_code) {
          timer.current = null;
          setCode(next.rfid_code);
          setReadAt(next.rfid_read_at ?? null);
          setStatus('read');
          dispatch(setValidation({ rfid_code: next.rfid_code, rfid_read_at: next.rfid_read_at }));
          return;
        }
      } catch {
        // Erreur réseau : on retente au prochain tick jusqu'au délai d'attente.
      }
      if (Date.now() >= deadline) {
        timer.current = null;
        setStatus('timeout');
        return;
      }
      timer.current = setTimeout(poll, POLL_INTERVAL_MS);
    }

    timer.current = setTimeout(poll, POLL_INTERVAL_MS);
  }, [installationId, dispatch, stop, t]);

  return { start, status, code, readAt, error };
}
