import { useState } from 'react';
import api from '@/services/api';
import { toast } from 'sonner';
import { setTokenForModule } from '@/utils/tokenManager';
import { maskTokenForLogging, secureLog, isDevelopment } from '@/utils/tokenSecurity';

/** Extrai token de body (data/raw) e headers da resposta /auth. */
function extractToken(response, raw, data) {
  const from = (obj) =>
    obj?.token ?? obj?.Token ?? obj?.access_token ?? obj?.accessToken ?? obj?.AccessToken;
  let t = from(data) ?? from(raw) ?? from(raw?.data);
  if (t && typeof t === 'string') return t.trim() || null;
  const h = response?.headers;
  if (h) {
    const x = h['x-access-token'];
    if (x && typeof x === 'string') return x.trim() || null;
    const auth = h['authorization'];
    if (auth && typeof auth === 'string' && /^\s*Bearer\s+/i.test(auth))
      return auth.replace(/^\s*Bearer\s+/i, '').trim() || null;
  }
  return null;
}

/**
 * Hook de autenticação do Workspace.
 * Implementa primeira autenticação (username/senha) e segunda autenticação (código 2FA)
 * conforme comunicação do backend via POST /auth.
 *
 * Primeira autenticação:
 *   POST /auth { username, password, Passo: 1, data_envio }
 *   - 200 + token → sucesso: armazena token, redireciona.
 *   - 200 + Result_Forme === "Autenticação" → exige 2FA: step 2, painel de código.
 *
 * Segunda autenticação:
 *   POST /auth { username, password, code_secret, Passo: 2 }
 *   - 200 + token → sucesso: armazena token, redireciona.
 *
 * @see .agent/project/WORKSPACE_BACKEND_ROUTES.md
 */
export const useWorkspaceAuth = () => {
  const [step, setStep] = useState(1);
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState('');
  const [userData, setUserData] = useState(null);
  const [otp, setOtp] = useState(['', '', '', '', '', '']);

  const validateFields = (username, password) => {
    setError('');
    if (!username || !String(username).trim()) {
      setError('Usuário é obrigatório.');
      return false;
    }
    if (!password || !String(password).trim()) {
      setError('Senha é obrigatória.');
      return false;
    }
    if (String(username).length > 250) {
      setError('Usuário excede o limite de 250 caracteres.');
      return false;
    }
    if (String(password).length > 250) {
      setError('Senha excede o limite de 250 caracteres.');
      return false;
    }
    if (username.includes('@')) {
      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      if (!emailRegex.test(username)) {
        setError('E-mail inválido.');
        return false;
      }
    }
    return true;
  };

  /**
   * Primeira autenticação: username, password, Passo 1.
   */
  const handleFirstLogin = async (username, password) => {
    setIsLoading(true);
    setError('');

    if (!validateFields(username, password)) {
      setIsLoading(false);
      return false;
    }

    const now = new Date();
    // Formato: YYYY-M-D (sem zeros à esquerda no mês/dia, mas sem espaço no final)
    const data_envio = `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()}`.trim();

    try {
      const response = await api.post('/auth', {
        username: String(username).trim(),
        password: String(password).trim(),
        Passo: 1,
        data_envio,
      });

      const raw = response?.data ?? response;
      const status = response?.status ?? raw?.Status ?? 0;
      const data = raw?.Base_Dados_API ?? raw;

      const token = extractToken(response, raw, data);
      if (import.meta.env?.DEV) {
        console.log('[WorkspaceAuth] 1ª autenticação —', { status, raw, data, token: token ? `${token.slice(0, 8)}…` : null });
      }

      if (token) {
        // Armazena token usando tokenManager para o módulo workspace (agora é async)
        setTokenForModule('workspace', token, 'Workspace').then(() => {
          // Mantém compatibilidade com token global (será criptografado pelo tokenManager)
          localStorage.setItem('workspace-auth-ok', '1');
          toast.success('Autenticação realizada com sucesso.');
          const base = (import.meta.env.BASE_URL || '/plataforma/').replace(/\/$/, '');
          window.location.replace(`${base}/workspace`);
        }).catch(err => {
          secureLog('Erro ao armazenar token do workspace', { error: err.message });
          toast.error('Erro ao salvar sessão. Tente novamente.');
        });
        return true;
      }

      const requires2FA = (() => {
        if (status !== 200) return false;
        const rf = data?.Result_Forme ?? data?.result_forme ?? data?.ResultForme ?? data?.result_Forme ?? raw?.Result_Forme ?? '';
        const r = String(rf).trim().toLowerCase().normalize('NFD').replace(/\u0300/g, '');
        if (r === 'autenticacao' || r === 'autenticação' || r.includes('autenticacao')) return true;
        if (data?.requires_2fa === true || data?.requer_2fa === true) return true;
        if (data?.Passo === 2 || data?.passo === 2) return true;
        if (data?.step === 2) return true;
        return false;
      })();

      const fallback2FA = (() => {
        if (status !== 200 || token) return false;
        const msg = String(data?.msg ?? data?.message ?? raw?.msg ?? raw?.message ?? '').toLowerCase();
        const authError = /inválid|invalida|incorret|erro|negad|unauthorized|credencial|senha.*erro|usuario.*inválid/i.test(msg);
        return !authError;
      })();

      if (requires2FA || fallback2FA) {
        setUserData({
          username: String(username).trim(),
          password: String(password).trim(),
          ...data,
        });
        setStep(2);
        setIsLoading(false);
        return true;
      }

      setError(data?.msg ?? data?.message ?? raw?.msg ?? raw?.message ?? 'Resposta inesperada do servidor.');
      setIsLoading(false);
      return false;
    } catch (err) {
      const msg = err?.response?.data?.msg ?? err?.response?.data?.message ?? err?.message;
      setError(msg || 'Ocorreu um erro ao se comunicar com o servidor. Tente novamente.');
      setIsLoading(false);
      return false;
    }
  };

  /**
   * Segunda autenticação: código 6 dígitos, Passo 2.
   */
  const handleSecondLogin = async (code) => {
    setIsLoading(true);
    setError('');

    const codigo = String(code ?? '').replace(/\D/g, '');
    if (codigo.length !== 6) {
      setError('Informe o código de verificação (6 dígitos).');
      setIsLoading(false);
      return false;
    }

    if (!userData?.username || !userData?.password) {
      setError('Dados de autenticação não encontrados. Faça login novamente.');
      setStep(1);
      setUserData(null);
      setOtp(['', '', '', '', '', '']);
      setIsLoading(false);
      return false;
    }

    try {
      const now = new Date();
      // Formato: YYYY-M-D (sem zeros à esquerda no mês/dia, mas sem espaço no final)
      const data_envio = `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()}`.trim();
      
      const payload = {
        username: userData.username,
        password: userData.password,
        code_secret: codigo,
        Passo: 2,
        data_envio,
      };

      const response = await api.post('/auth', payload);
      const raw = response?.data ?? response;
      const data = raw?.Base_Dados_API ?? raw;
      const token = extractToken(response, raw, data);

      if (import.meta.env?.DEV) {
        console.log('[WorkspaceAuth] 2ª autenticação —', { raw, data, token: token ? `${token.slice(0, 8)}…` : null });
      }

      if (token) {
        // Armazena token usando tokenManager para o módulo workspace (agora é async)
        setTokenForModule('workspace', token, 'Workspace').then(() => {
          // Mantém compatibilidade com token global (será criptografado pelo tokenManager)
          localStorage.setItem('workspace-auth-ok', '1');
          toast.success('Autenticação em duas etapas concluída. Redirecionando...');
          setUserData(null);
          setOtp(['', '', '', '', '', '']);
          const base = (import.meta.env.BASE_URL || '/plataforma/').replace(/\/$/, '');
          window.location.replace(`${base}/workspace`);
        }).catch(err => {
          secureLog('Erro ao armazenar token do workspace', { error: err.message });
          toast.error('Erro ao salvar sessão. Tente novamente.');
        });
        return true;
      }

      // Se o backend retornou 200 mas não há token, assumimos que a autenticação foi concluída
      // (por exemplo, via cookie de sessão) e liberamos o acesso ao Workspace via flag.
      const status = response?.status ?? raw?.Status ?? 0;
      if (status === 200) {
        localStorage.setItem('workspace-auth-ok', '1');
        toast.success('Autenticação concluída. Redirecionando para o Workspace...');
        setUserData(null);
        setOtp(['', '', '', '', '', '']);
        const base = (import.meta.env.BASE_URL || '/plataforma/').replace(/\/$/, '');
        window.location.replace(`${base}/workspace`);
        return true;
      }

      const backendMsg = data?.msg ?? data?.message ?? raw?.msg ?? raw?.message;
      const fallbackMsg = backendMsg || 'Código inválido. Tente novamente.';
      setError(fallbackMsg);
      setIsLoading(false);
      return false;
    } catch (err) {
      const msg = err?.response?.data?.msg ?? err?.response?.data?.message ?? err?.message;
      setError(msg || 'Erro ao validar código. Tente novamente.');
      setIsLoading(false);
      return false;
    }
  };

  const reset = () => {
    setStep(1);
    setError('');
    setUserData(null);
    setOtp(['', '', '', '', '', '']);
  };

  return {
    step,
    isLoading,
    error,
    otp,
    setOtp,
    handleFirstLogin,
    handleSecondLogin,
    reset,
  };
};
