import React, { useState, useMemo, useEffect, useCallback } from 'react';
import { useNavigate } from 'react-router-dom';
import { Search, Plus, Filter, X, Loader2, Archive, Download } from 'lucide-react';
import { downloadAprovados } from '../services/driverService';
import { toast } from 'sonner';
import { handleGrError } from '../utils/grErrorHandler';
import ExcelTable from '../components/ExcelTable';


import { GrKanbanBoard } from '../components/GrKanbanBoard';
import { GrRegistrationDetails } from '../components/GrRegistrationDetails';
import { useGrStore } from '../services/useGrStore';
import * as grService from '../services/grService';

const RegistrationsView = () => {
  const navigate = useNavigate();
  const { userData } = useGrStore();
  const [viewMode, setViewMode] = useState('painel'); // 'painel' (kanban) or 'table'
  const [filterType, setFilterType] = useState('Interno'); // Align with legacy "Cadastro Interno" / "Cadastro Externo"
  const [searchTerm, setSearchTerm] = useState('');
  const [selectedCard, setSelectedCard] = useState(null);
  const [data, setData] = useState([]);
  const [bases, setBases] = useState([]);
  const [loading, setLoading] = useState(false);
  const [isDownloading, setIsDownloading] = useState(false);

  const handleExport = async () => {
    setIsDownloading(true);
    try {
      await downloadAprovados();
    } catch (err) {
      console.error('[RegistrationsView] Erro ao exportar aprovados:', err);
    } finally {
      setIsDownloading(false);
    }
  };
  const [contracts, setContracts] = useState([]);
  const [allContracts, setAllContracts] = useState([]); // Todos os contratos para verificar bloqueio

  const userGroup = userData?.usuario?.grupo || 'Administrador';
  const userBase = userData?.usuario?.base || '';

  const fetchData = useCallback(async () => {
    // If we have userData but not the 'usuario' sub-object, something is wrong
    if (!userData || !userData.usuario) {
      console.warn("GR: No user data available yet to fetch registrations.");
      return;
    }
    
    setLoading(true);
    try {
      // Fetch Bases for filters
      const basesResp = await grService.getBases();
      const basesList = basesResp.Base_Dados_API || basesResp.dados || basesResp || [];
      setBases(Array.isArray(basesList) ? basesList : []);

      const params = {
        grupo: userGroup,
        base: typeof userBase === 'string' && userBase.includes(',') ? userBase.split(',').map(b => b.trim()) : (Array.isArray(userBase) ? userBase : [userBase]),
        filtro: `Cadastro ${filterType}`
      };
      
      console.log("GR: Fetching registrations with params:", params);
      const response = await grService.getDriversByFilter(params);
      
      // Handle legacy wrapper or direct data
      const driverData = response.Base_Dados_API || response.dados || response;
      setData(Array.isArray(driverData) ? driverData : (driverData.dados || []));

      // Buscar todos os contratos para verificar bloqueio de Agregado/Rentals
      try {
        const allContractsResp = await grService.getActiveContracts();
        const allContractsData = allContractsResp.Base_Dados_API || allContractsResp.dados || allContractsResp || [];
        setAllContracts(Array.isArray(allContractsData) ? allContractsData : []);
      } catch (error) {
        console.error("Error fetching all contracts:", error);
      }

      if (userGroup === 'Despachante' || userGroup === 'Coordenador') {
        const contractsResp = await grService.getDriverContracts(userBase);
        const contractData = contractsResp.Base_Dados_API || contractsResp.dados || contractsResp;
        setContracts(Array.isArray(contractData) ? contractData : []);
      }
    } catch (error) {
      handleGrError(error, "Não foi possível carregar os cadastros.");
    } finally {
      setLoading(false);
    }
  }, [userData, userGroup, userBase, filterType]);

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

  const handleCardMove = async (cardId, newStatusUi) => {
    // Verificar se o cadastro tem modalidade Agregado ou Rentals e se pode ser movido
    const registration = data.find(r => r.iddrivers === cardId);
    
    // Helper para normalizar modalidade
    const normalizeModalidade = (modalidade) => {
      if (!modalidade) return '';
      return String(modalidade).trim();
    };
    
    const modalidade = normalizeModalidade(registration?.modalidade);
    const isBlocked = modalidade === 'Agregado' || modalidade === 'Rentals';
    
    // Se for modalidade bloqueada, verificar se tem contrato assinado
    if (isBlocked && newStatusUi !== 'aguardando') {
      // Verificar se tem contrato assinado
      const contract = allContracts.find(c => c.iddrivers === cardId);
      const isSigned = contract?.status_assinatura === 'Assinado' || contract?.global_status === 'Assinados';
      
      if (!isSigned) {
        toast.error("Cadastros com modalidade Agregado ou Rentals não podem sair de 'Aguardando Análise' até terem contrato ASSINADO.");
        return;
      }
    }

    // Map UI status back to API status if necessary
    // Legacy statuses: "Aguardando Análise GR", "Em Análise", "Pendências / Revisão", "Aprovado", "Recusado"
    const statusMap = {
      'aguardando': 'Aguardando Análise GR',
      'analise': 'Em Análise',
      'pendencias': 'Pendências / Revisão',
      'aprovado': 'Aprovado',
      'recusado': 'Recusado'
    };

    const apiStatus = statusMap[newStatusUi] || newStatusUi;

    try {
      await grService.updateDriverStatus({
        iddrivers: cardId,
        global_status: apiStatus
      });

      // Se mover para pendências, atualiza também os status de doc motorista e carro conforme solicitado
      if (newStatusUi === 'pendencias') {
         // Recupera o card atual dos dados locais para obter os valores atuais ou definir um padrão
         const currentCard = data.find(d => d.iddrivers === cardId);
         // Só chama á rota quando ambos os status estão preenchidos para evitar erros
         if (currentCard && currentCard.status_doc_motorista && currentCard.status_doc_carro) {
            await grService.updateDriverDocStatus({
                iddrivers: cardId,
                status_doc_motorista: currentCard.status_doc_motorista,
                status_doc_carro: currentCard.status_doc_carro
            });
         }
      }
      
      // Optimistic update or refetch
      setData(prev => prev.map(item => 
        item.iddrivers === cardId ? { ...item, global_status: apiStatus } : item
      ));
    } catch (error) {
      handleGrError(error, "Erro ao atualizar status.");
    }
  };

  const filteredData = useMemo(() => {
    if (!data) return [];
    
    // Filter only by search term, as data is already filtered by API (base and filterType)
    if (!searchTerm) return data;

    const lowerSearch = searchTerm.toLowerCase();
    return data.filter(d => 
      d && (
        d.nome_completo?.toLowerCase().includes(lowerSearch) ||
        d.cpf?.includes(searchTerm) ||
        d.placa_veiculo?.toLowerCase().includes(lowerSearch)
      )
    );
  }, [data, searchTerm]);



  // Kanban Configuration aligned with Legacy
  const kanbanColumns = useMemo(() => {
    let cols = [];

    if (userGroup === 'Despachante' || userGroup === 'Coordenador') {
      cols = [
        { id: 'aguardando', title: 'Aguardando Análise', color: 'slate', statusKeys: ['Aguardando Análise GR', 'Aguardando Análise'] },
        { id: 'analise', title: 'Em Análise', color: 'blue', statusKeys: ['Em Análise'] },
        { id: 'pendencias', title: 'Pendências / Revisão', color: 'orange', statusKeys: ['Pendências / Revisão'] },
        { id: 'aprovado', title: 'Aprovado', color: 'emerald', statusKeys: ['Aprovado'] },
        { id: 'recusado', title: 'Recusado', color: 'red', statusKeys: ['Recusado'] },
        { id: 'contratos', title: 'Contratos', color: 'blue', isContract: true }
      ];

    } else if (userGroup === 'Documentação') {
      cols = [
        { id: 'aguardando', title: 'Aguardando Análise', color: 'slate', statusKeys: ['Aguardando Análise GR', 'Aguardando Análise'] },
        { id: 'analise', title: 'Em Análise', color: 'blue', statusKeys: ['Em Análise'] },
        { id: 'pendencias', title: 'Pendências / Revisão', color: 'orange', statusKeys: ['Pendências / Revisão'] },
        { id: 'aprovado', title: 'Aprovado', color: 'emerald', statusKeys: ['Aprovado'] },
        { id: 'recusado', title: 'Recusado', color: 'red', statusKeys: ['Recusado'] }
      ];
    } else {
      cols = [
        { id: 'aguardando', title: 'Aguardando Análise', color: 'slate', statusKeys: ['Aguardando Análise GR', 'Aguardando Análise'] },
        { id: 'analise', title: 'Em Análise', color: 'blue', statusKeys: ['Em Análise'] },
        { id: 'pendencias', title: 'Pendências / Revisão', color: 'orange', statusKeys: ['Pendências / Revisão'] },
        { id: 'aprovado', title: 'Aprovado', color: 'emerald', statusKeys: ['Aprovado'] },
        { id: 'recusado', title: 'Recusado', color: 'red', statusKeys: ['Recusado'] }
      ];
    }


      // Helper para normalizar modalidade
      const normalizeModalidade = (modalidade) => {
        if (!modalidade) return '';
        return String(modalidade).trim();
      };

      return cols.map(col => {
        let cards = [];

        if (col.isContract) {
          // Contratos logic (Specific for Dispatchers who have this column)
          // Contratos logic (Specific for Dispatchers who have this column)
          cards = contracts.map(c => {
             // Tenta buscar o cadastro para obter CPF e Base caso não existam no objeto de contrato
             // Note: 'data' pode estar filtrado, então isso é uma tentativa de melhoria
             const registration = data.find(r => r.iddrivers === c.iddrivers);
             const cpfValue = c.cpf || registration?.cpf || 'N/A';
             
             // Base logic: try contract base, then registration base, then user base
             const baseValue = c.base_driver || c.base || registration?.base || userBase || 'N/A';

              // Formatar data de assinatura
              const formatDate = (dateStr) => {
                if (!dateStr) return 'N/A';
                if (dateStr.includes('00:00:00')) {
                  return dateStr.split(' ')[0];
                }
                return dateStr;
              };

             return {
                ...c,
                id: c.iddrivers,
                title: c.nome_completo || c.nome || `ID: ${c.iddrivers}`,
                subtitle: `CPF: ${cpfValue}`,
                date: formatDate(c.data_assinatura), // Footer date: Data da assinatura
                base: baseValue, // Footer location: Base
                details: [ 
                    { label: 'Base', value: baseValue },
                    { label: 'Tipo Contrato', value: c.tipo_contract || "Sem Contrato" },
                    { label: 'Status Assinatura', value: c.status_assinatura || "Pendente" },
                    { label: 'Admissão', value: c.data_admissao || 'Não informado' }
                ]
             };
          });
        } else {
          // Standard registration mapping for all roles
          cards = filteredData
            .filter(d => {
              if (!d) return false;
              // Blocking logic: Agregado/Rentals without signed contract only show in 'Aguardando Análise'
              const modalidade = normalizeModalidade(d.modalidade);
              const isBlocked = modalidade === 'Agregado' || modalidade === 'Rentals';
              
              if (isBlocked) {
                const contract = allContracts.find(c => c.iddrivers === d.iddrivers);
                const hasSignedContract = contract?.status_assinatura === 'Assinado';
                
                if (!hasSignedContract && col.id !== 'aguardando') {
                    return false;
                }
              }

              const currentStatus = d.global_status || d.STATUS || d.status;
              return col.statusKeys.includes(currentStatus);
            })
            .map((d, dIdx) => {
              const modalidade = normalizeModalidade(d.modalidade);
              const isBlocked = modalidade === 'Agregado' || modalidade === 'Rentals';
              const contract = allContracts.find(c => c.iddrivers === d.iddrivers);
              const isSigned = contract?.status_assinatura === 'Assinado' || contract?.global_status === 'Assinados';
              const cardIsBlocked = isBlocked && !isSigned;
              
              return {
                ...d,
                id: d.iddrivers || `temp-${dIdx}`,
                title: d.nome_completo || 'Sem Nome',
                subtitle: d.cpf || 'Sem CPF',
                date: d.data_cadastro || d.data_envio || '',
                base: d.base || 'Sem Base',
                details: [ { label: 'Placa', value: d.placa_veiculo }, { label: 'Modalidade', value: d.modalidade } ],
                isBlocked: cardIsBlocked,
                status: d.global_status
              };
            });
        }

        return {
          ...col,
          cards
        };
      });

  }, [filteredData, contracts, allContracts, userGroup, userBase]);

  // Table Configuration
  const tableColumns = useMemo(() => {
    const baseCols = [
      { field: 'nome_completo', header: 'Nome', width: 200 },
      { field: 'base', header: 'Base', width: 100 },
      { field: 'cpf', header: 'CPF', width: 140 },
      { field: 'placa_veiculo', header: 'Placa', width: 120 },
      { field: 'modalidade', header: 'Modalidade', width: 120 }
    ];

    if (userGroup === 'Despachante' || userGroup === 'Documentação' || userGroup === 'Administrador') {
      baseCols.push(
        { field: 'telefone', header: 'Telefone', width: 140 },
        { field: 'endereco', header: 'Endereço', width: 250 },
        { field: 'cidade', header: 'Cidade', width: 150 }
      );
    }

    baseCols.push({ field: 'global_status', header: 'Status Global', width: 140, render: (row) => (
      <span className={`px-2 py-1 rounded-full text-xs font-bold ${
        row.global_status === 'Aprovado' ? 'bg-emerald-100 text-emerald-700' :
        row.global_status === 'Recusado' ? 'bg-red-100 text-red-700' :
        row.global_status === 'Pendências / Revisão' ? 'bg-orange-100 text-orange-700' :
        'bg-slate-100 text-slate-700'
      }`}>
        {row.global_status}
      </span>
    )});

    return baseCols;
  }, [userGroup]);


  const handleSave = async (updatedData) => {
    try {
      console.log("GR: Saving driver registration data:", updatedData);

      // Inject required admin fields
      const finalPayload = {
        ...updatedData,
        grupo: userGroup,
        base_usuario: userBase || 'Sem resposta',
        data_envio: new Date().toLocaleDateString('pt-BR').split('/').reverse().join('-') + ' ' // YYYY-MM-DD format roughly or just keeping user format
      };

      await grService.updateDriverRegistration(finalPayload);
      
      // Se o status global mudou no formulário, atualiza pelo endpoint específico
      if (updatedData.global_status !== selectedCard.global_status) {
        await grService.updateDriverStatus({
          iddrivers: updatedData.iddrivers,
          global_status: updatedData.global_status
        });
      }

      // Check for document status updates and call specific endpoint if needed
      if (updatedData.status_doc_motorista || updatedData.status_doc_carro) {
          await grService.updateDriverDocStatus({
            iddrivers: updatedData.iddrivers,
            status_doc_motorista: updatedData.status_doc_motorista,
            status_doc_carro: updatedData.status_doc_carro
          });
      }

      fetchData();
      setSelectedCard(null);
    } catch (error) {
      handleGrError(error, "Erro ao salvar alterações.");
    }
  };

  const handleNextStatus = async (cardData) => {
    const statusList = [
      "Aguardando Análise GR",
      "Em Análise",
      "Pendências / Revisão",
      "Aprovado",
      "Recusado",
    ];

    const currentIndex = statusList.indexOf(cardData.global_status);
    let nextIndex = currentIndex + 1;

    if (nextIndex >= statusList.length) {
      // Loop back or stop? Legacy does indexAtual < Status_list.length - 1
      return;
    }

    const nextStatus = statusList[nextIndex];

    try {
      await grService.updateDriverStatus({
        iddrivers: cardData.iddrivers,
        global_status: nextStatus
      });
      fetchData();
      setSelectedCard(null);
    } catch (error) {
      handleGrError(error, "Erro ao avançar status.");
    }
  };

  const handleApprove = async (cardData) => {
    try {
      await grService.updateDriverStatus({
        iddrivers: cardData.iddrivers,
        global_status: 'Aprovado'
      });
      fetchData();
      setSelectedCard(null);
    } catch (error) {
      handleGrError(error, "Erro ao aprovar.");
    }
  };

  const handleReject = async (cardData) => {
    try {
      await grService.updateDriverStatus({
        iddrivers: cardData.iddrivers,
        global_status: 'Recusado'
      });
      fetchData();
      setSelectedCard(null);
    } catch (error) {
      handleGrError(error, "Erro ao reprovar.");
    }
  };

  return (
    <div className="flex flex-col h-full gap-4 md:gap-8 relative">
      {/* Header Section */}
      <div className="flex flex-col gap-8">
        <div className="flex flex-col xl:flex-row xl:items-end justify-between gap-8">
          <div className="space-y-1">
            <h1 className="text-3xl md:text-5xl font-bold text-slate-800 dark:text-white tracking-tighter leading-none">
              Gestão de <span className="text-[var(--gr-primary)]">Cadastros</span>
            </h1>
            <p className="text-slate-400 dark:text-slate-500 text-sm md:text-base font-medium italic opacity-80">
              {(userGroup === 'Despachante' || userGroup === 'Coordenador') ? `Visão simplificada para ${userGroup}s` : 
               userGroup === 'Documentação' ? 'Consulta de Cadastros' : 
               'Acompanhamento integrado de novos candidatos e parceiros'}
            </p>

          </div>

          <div className="flex flex-wrap items-center gap-4">
            {(userGroup === 'Documentação' || userGroup === 'Administrador') && (
              <div className="flex bg-slate-100 dark:bg-slate-800/50 p-1.5 rounded-[24px] border border-slate-200 dark:border-white/5 shadow-inner">
                  <button 
                    onClick={() => setViewMode('painel')}
                    className={`px-6 py-2.5 rounded-[20px] text-[10px] font-bold uppercase tracking-wider transition-all duration-300 ${viewMode === 'painel' ? 'bg-white dark:bg-slate-700 shadow-lg text-[var(--gr-primary)] dark:text-white transform scale-[1.05]' : 'text-slate-500 hover:text-slate-700 dark:hover:text-slate-300'}`}
                  >
                    Painel
                  </button>
                  <button 
                    onClick={() => setViewMode('table')}
                    className={`px-6 py-2.5 rounded-[20px] text-[10px] font-bold uppercase tracking-wider transition-all duration-300 ${viewMode === 'table' ? 'bg-white dark:bg-slate-700 shadow-lg text-[var(--gr-primary)] dark:text-white transform scale-[1.05]' : 'text-slate-500 hover:text-slate-700 dark:hover:text-slate-300'}`}
                  >
                    Tabela
                  </button>
              </div>
            )}


            {/* Filter Toggle */}
            <div className="flex items-center bg-slate-100 dark:bg-slate-800/50 p-1.5 rounded-[24px] border border-slate-200 dark:border-white/5 shadow-inner">
              <span className="pl-4 pr-2 text-[9px] font-bold text-slate-400 uppercase tracking-widest hidden lg:block self-center mt-0.5">Filtro:</span>
              <button 
                onClick={() => setFilterType('Externo')}
                className={`px-6 py-2.5 rounded-[20px] text-[10px] font-bold uppercase tracking-wider transition-all duration-300 ${filterType === 'Externo' ? 'bg-white dark:bg-slate-700 shadow-lg text-slate-800 dark:text-white transform scale-[1.05]' : 'text-slate-500 hover:text-slate-700 dark:hover:text-slate-300'}`}
              >
                Externo
              </button>
              <button 
                onClick={() => setFilterType('Interno')}
                className={`px-6 py-2.5 rounded-[20px] text-[10px] font-bold uppercase tracking-wider transition-all duration-300 ${filterType === 'Interno' ? 'bg-white dark:bg-slate-700 shadow-lg text-slate-800 dark:text-white transform scale-[1.05]' : 'text-slate-500 hover:text-slate-700 dark:hover:text-slate-300'}`}
              >
                Interno
              </button>
            </div>

            {/* Search */}
            <div className="relative group flex-1 min-w-[260px] max-w-[450px]">
              <Search size={16} className="absolute left-4 top-1/2 -translate-y-1/2 text-slate-400 group-focus-within:text-[var(--gr-primary)] transition-colors" />
              <input 
                type="text" 
                placeholder="Busque por nome, CPF ou placa..." 
                value={searchTerm}
                onChange={(e) => setSearchTerm(e.target.value)}
                className="pl-12 pr-14 py-3.5 w-full bg-slate-50 dark:bg-slate-900/50 border border-slate-200 dark:border-white/5 rounded-[24px] text-xs focus:outline-none focus:ring-4 focus:ring-[var(--gr-primary)]/10 focus:border-[var(--gr-primary)] transition-all font-semibold shadow-sm"
              />
            </div>

            {/* Arquivados - Despachante e Coordenador não têm acesso */}
            {userGroup !== 'Despachante' && userGroup !== 'Coordenador' && userGroup !== 'Documentação' && (
              <button 
                type="button"
                onClick={() => navigate('/plataforma/gr/cadastros/arquivados')}
                className="flex items-center gap-2 px-6 py-3 bg-slate-100 dark:bg-slate-800 hover:bg-slate-200 dark:hover:bg-slate-700 text-slate-700 dark:text-slate-200 rounded-[24px] font-bold text-[11px] uppercase tracking-widest transition-all"
              >
                <Archive size={16} />
                Arquivados
              </button>
            )}

            {/* Exportar Aprovados */}
            {userGroup !== 'Despachante' && userGroup !== 'Coordenador' && (
              <button
                type="button"
                onClick={handleExport}
                disabled={isDownloading}
                className="flex items-center gap-2 px-6 py-3 bg-emerald-500 hover:bg-emerald-600 active:bg-emerald-700 disabled:opacity-60 disabled:cursor-not-allowed text-white rounded-[24px] font-bold text-[11px] uppercase tracking-widest transition-all shadow-lg shadow-emerald-500/20"
              >
                {isDownloading ? <Loader2 size={16} className="animate-spin" /> : <Download size={16} />}
                {isDownloading ? 'Exportando...' : 'Exportar Aprovados'}
              </button>
            )}

            {/* Add Button */}
            {userGroup !== 'Documentação' && (
              <button 
                onClick={() => {
                  sessionStorage.removeItem('info');
                  navigate('novo');
                }}
                className="flex items-center gap-2 px-8 py-3.5 bg-[var(--gr-primary)] hover:bg-[var(--gr-primary-dark)] text-white rounded-[24px] font-bold text-[11px] uppercase tracking-widest transition-all shadow-xl shadow-[var(--gr-primary)]/25 hover:scale-[1.02] active:scale-95 whitespace-nowrap"
              >
                <Plus size={18} strokeWidth={3} />
                Novo Cadastro
              </button>
            )}

          </div>
        </div>
      </div>
      
      {/* Content Area */}
      <div className="flex-1 min-h-0">
        {loading ? (
          <div className="flex h-full w-full items-center justify-center">
            <Loader2 className="animate-spin text-[var(--gr-primary)]" size={32} />
          </div>
        ) : (
          viewMode === 'painel' ? (
            <GrKanbanBoard 
              columns={kanbanColumns} 
              userRole={userGroup}
              onCardClick={(card) => {
                if (userGroup === 'Despachante' || userGroup === 'Coordenador') {
                  // Only 'Pendências / Revisão' allows interaction (navigation to form)
                  if (card.status === 'Pendências / Revisão') {
                    sessionStorage.setItem('info', JSON.stringify(card));
                    navigate('novo');
                  } else {
                    // All other statuses are visualization only in the Kanban (no modal)
                    toast.info("Acesso restrito", {
                      description: "Para este status, apenas a visualização básica no Kanban está disponível."
                    });
                  }
                } else {
                  // Documentação or Admin
                  setSelectedCard(card);
                }
              }}


              onCardMove={userGroup === 'Documentação' ? null : handleCardMove}
            />

          ) : (
            <ExcelTable 
              data={filteredData} 
              columns={tableColumns} 
              pageSize={10}
              loading={false}
              hideActions={true}
              onRowClick={setSelectedCard}
              filterDefs={[
                { field: 'base', header: 'Base', type: 'select' },
                { field: 'modalidade', header: 'Modalidade', type: 'select' },
                { field: 'global_status', header: 'Status', type: 'select' }
              ]}
              filterOptions={{
                base: bases.map(b => b.base || b.nome).filter(Boolean).sort()
              }}
            />
          )
        )}
      </div>

      {/* Detail Modal Overlay */}
      {selectedCard && (
        <div className="fixed inset-0 z-50 bg-black/60 backdrop-blur-sm flex items-center justify-center p-4 md:p-8 animate-in fade-in duration-200">
           <div className="bg-white dark:bg-[#141414] w-full max-w-7xl h-full max-h-[90vh] rounded-[24px] shadow-2xl overflow-hidden flex flex-col animate-in zoom-in-95 duration-200">
              <GrRegistrationDetails 
                data={selectedCard}
                onClose={() => setSelectedCard(null)}
                isReadOnly={userGroup === 'Documentação' || ((userGroup === 'Despachante' || userGroup === 'Coordenador') && selectedCard?.global_status !== 'Pendências / Revisão')}
                onSave={handleSave}
                onNext={() => handleNextStatus(selectedCard)}

                onApprove={handleApprove}
                onReject={handleReject}
                onArchive={async (cardData) => {
                  try {
                    await grService.archiveDriverRegistration(cardData.iddrivers);
                    toast.success("Cadastro arquivado com sucesso!");
                    fetchData();
                    setSelectedCard(null);
                  } catch (error) {
                    handleGrError(error, "Erro ao arquivar cadastro.");
                  }
                }}
              />
           </div>
        </div>
      )}
    </div>
  );
};

export default RegistrationsView;

