/**
 * 🔐 AUTHORIZATION SYSTEM - Sistema Centralizado de Autorização
 * 
 * Este é o ÚNICO lugar onde decisões de autorização são tomadas.
 * TODA verificação de permissão DEVE passar por este sistema.
 * 
 * ✅ FASE 4 FIX: Suporte completo a permissões granulares por módulo/documento/ação
 * 
 * ARQUITETURA:
 * 1. Super Admin → BYPASS total
 * 2. Admin da Empresa → BYPASS para sua empresa
 * 3. Gerente → Todas permissões configuradas
 * 4. Usuário → Apenas permissões granulares configuradas
 * 5. Permissões granulares TEM PRIORIDADE sobre permissões genéricas
 * 
 * REGRAS DE AUTORIZAÇÃO:
 * - Super Admin TOnline: acesso total a TUDO
 * - Admin da Empresa: acesso total dentro de sua empresa
 * - Gerente: todas as permissões configuradas
 * - Usuário: somente permissões granulares específicas
 * - Documentos em estados bloqueados requerem permissões especiais
 * - Documentos com vínculos não podem ser editados/deletados
 */

import { createClient } from '../../src/compat/supabase.js';

const supabaseUrl = Deno.env.get('SUPABASE_URL')!;
const supabaseServiceKey = Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!;

// ========== TIPOS ==========

type Action = 
  | 'criar'
  | 'editar'
  | 'visualizar'
  | 'deletar'
  | 'anular'
  | 'aprovar'
  | 'rejeitar'
  | 'emitir'
  | 'exportar-saft'
  | 'gerenciar-usuarios'
  | 'configurar-empresa'
  | 'visualizar-logs'
  | 'conceder-permissoes';

type AcaoDocumento = 'criar' | 'editar' | 'visualizar' | 'deletar' | 'anular';

type EstadoDocumento = 
  | 'rascunho'
  | 'pendente'
  | 'aprovado'
  | 'rejeitado'
  | 'emitido'
  | 'anulado';

interface Permissoes {
  concederPermissoes: boolean;
  visualizarLogs: boolean;
  gerenciarUsuarios: boolean;
  exportarSAFT: boolean;
  configurarEmpresa: boolean;
}

interface Usuario {
  id: string;
  email: string;
  nivel: 'superadmin_tonline' | 'admin' | 'gerente' | 'usuario';
  empresaId: string;
  permissoes: Permissoes;
  permissoesModulos?: any; // Estrutura de permissões granulares (compatibilidade)
}

interface Documento {
  id: string;
  tipo: string;
  estado: EstadoDocumento;
  empresaId: string;
  criadoPor?: string;
}

interface AuthorizationResult {
  permitido: boolean;
  motivo: string;
  metadata?: {
    usuario: string;
    nivel: string;
    acao: string;
    recurso?: string;
    permissaoGranular?: string;
    timestamp: string;
  };
}

interface AuthorizationLog {
  timestamp: string;
  usuario: {
    id: string;
    email: string;
    nivel: string;
  };
  acao: string;
  recurso?: {
    tipo: string;
    id: string;
    estado: string;
  };
  resultado: 'PERMITIDO' | 'NEGADO';
  motivo: string;
}

// ========== CONSTANTES ==========

const ESTADOS_BLOQUEADOS: EstadoDocumento[] = ['emitido', 'aprovado', 'anulado'];

const ACAO_PARA_PERMISSAO: Record<Action, keyof Permissoes | 'bypass'> = {
  'criar': 'criarDocumento',
  'editar': 'editarDocumentoPendente',
  'visualizar': 'bypass', // Visualizar não requer permissão específica
  'deletar': 'deletarDocumento',
  'anular': 'anularDocumento',
  'aprovar': 'editarDocumentoPendente',
  'rejeitar': 'editarDocumentoPendente',
  'emitir': 'editarDocumentoPendente',
  'exportar-saft': 'exportarSAFT',
  'gerenciar-usuarios': 'gerenciarUsuarios',
  'configurar-empresa': 'configurarEmpresa',
  'visualizar-logs': 'visualizarLogs',
  'conceder-permissoes': 'concederPermissoes',
};

// ========== FUNÇÕES DE LOG ==========

function logAuthorization(log: AuthorizationLog): void {
  const emoji = log.resultado === 'PERMITIDO' ? '✅' : '❌';
  
  console.log(`\n${emoji} [AUTHORIZATION] ${log.resultado}`);
  console.log(`   Timestamp: ${log.timestamp}`);
  console.log(`   Usuário: ${log.usuario.email} (${log.usuario.nivel})`);
  console.log(`   Ação: ${log.acao}`);
  
  if (log.recurso) {
    console.log(`   Recurso: ${log.recurso.tipo} (${log.recurso.estado})`);
    console.log(`   ID: ${log.recurso.id}`);
  }
  
  console.log(`   Motivo: ${log.motivo}`);
  console.log('');
}

// ========== FUNÇÃO PRINCIPAL DE AUTORIZAÇÃO ==========

/**
 * 🔐 FUNÇÃO CENTRAL DE AUTORIZAÇÃO
 * 
 * Esta é a ÚNICA função que decide se uma ação é permitida ou não.
 * TODAS as verificações de permissão devem passar por aqui.
 * 
 * ✅ FASE 4 FIX: Suporte a permissões granulares por módulo/documento/ação
 * 
 * ORDEM DE VERIFICAÇÃO:
 * 1. Super Admin TOnline → SEMPRE permitido
 * 2. Admin da Empresa → Permitido para sua empresa
 * 3. Gerente → Permitido se tem a permissão
 * 4. Permissões Granulares → PRIORIDADE sobre permissões genéricas
 * 5. Permissões Genéricas → Fallback
 * 6. Estado do Documento → Verificar se pode modificar
 * 7. Vínculos → Verificar se documento tem vínculos
 * 
 * @param usuario - Usuário fazendo a ação
 * @param acao - Ação a ser realizada
 * @param documento - Documento (opcional, para ações específicas de documento)
 * @returns Resultado da autorização com motivo
 */
export async function can(
  usuario: Usuario,
  acao: Action,
  documento?: Documento
): Promise<AuthorizationResult> {
  const timestamp = new Date().toISOString();
  
  console.log(`\n🔐 [can] Verificando autorização:`);
  console.log(`   Usuário: ${usuario.email} (${usuario.nivel})`);
  console.log(`   Ação: ${acao}`);
  if (documento) {
    console.log(`   Documento: ${documento.tipo} (${documento.estado})`);
  }
  
  // Requisito Financas/AT: administradores ja nao tem acesso incondicional -
  // uma permissao granular explicitamente negada (false) e sempre
  // respeitada, mesmo para super_admin/admin. Ausencia de configuracao
  // (null) continua a conceder acesso por omissao a estes niveis.
  const permissaoGranularExplicita = verificarPermissaoGranular(usuario, acao, documento?.tipo);
  if (permissaoGranularExplicita === false && (usuario.nivel === 'superadmin_tonline' || usuario.nivel === 'admin')) {
    const result: AuthorizationResult = {
      permitido: false,
      motivo: `Permissao '${acao}' negada explicitamente para ${documento?.tipo || 'este recurso'}`,
      metadata: { usuario: usuario.email, nivel: usuario.nivel, acao, recurso: documento?.tipo, timestamp },
    };
    logAuthorization({
      timestamp,
      usuario: { id: usuario.id, email: usuario.email, nivel: usuario.nivel },
      acao,
      recurso: documento ? { tipo: documento.tipo, id: documento.id, estado: documento.estado } : undefined,
      resultado: 'NEGADO',
      motivo: result.motivo,
    });
    return result;
  }

  // ========== REGRA 1: SUPER ADMIN TONLINE ==========

  if (usuario.nivel === 'superadmin_tonline') {
    const result: AuthorizationResult = {
      permitido: true,
      motivo: 'Super Admin TOnline tem acesso total',
      metadata: {
        usuario: usuario.email,
        nivel: usuario.nivel,
        acao,
        recurso: documento?.tipo,
        timestamp,
      },
    };
    
    logAuthorization({
      timestamp,
      usuario: {
        id: usuario.id,
        email: usuario.email,
        nivel: usuario.nivel,
      },
      acao,
      recurso: documento ? {
        tipo: documento.tipo,
        id: documento.id,
        estado: documento.estado,
      } : undefined,
      resultado: 'PERMITIDO',
      motivo: result.motivo,
    });
    
    return result;
  }
  
  // ========== REGRA 2: ADMIN DA EMPRESA ==========
  
  if (usuario.nivel === 'admin') {
    // Verificar se está acessando recursos de sua própria empresa
    if (documento && documento.empresaId !== usuario.empresaId) {
      const result: AuthorizationResult = {
        permitido: false,
        motivo: 'Admin só pode acessar recursos de sua própria empresa',
        metadata: {
          usuario: usuario.email,
          nivel: usuario.nivel,
          acao,
          recurso: documento.tipo,
          timestamp,
        },
      };
      
      logAuthorization({
        timestamp,
        usuario: {
          id: usuario.id,
          email: usuario.email,
          nivel: usuario.nivel,
        },
        acao,
        recurso: {
          tipo: documento.tipo,
          id: documento.id,
          estado: documento.estado,
        },
        resultado: 'NEGADO',
        motivo: result.motivo,
      });
      
      return result;
    }
    
    // Admin tem acesso total dentro de sua empresa
    const result: AuthorizationResult = {
      permitido: true,
      motivo: 'Admin tem acesso total dentro de sua empresa',
      metadata: {
        usuario: usuario.email,
        nivel: usuario.nivel,
        acao,
        recurso: documento?.tipo,
        timestamp,
      },
    };
    
    logAuthorization({
      timestamp,
      usuario: {
        id: usuario.id,
        email: usuario.email,
        nivel: usuario.nivel,
      },
      acao,
      recurso: documento ? {
        tipo: documento.tipo,
        id: documento.id,
        estado: documento.estado,
      } : undefined,
      resultado: 'PERMITIDO',
      motivo: result.motivo,
    });
    
    return result;
  }
  
  // ========== REGRA 3: GERENTE ==========
  
  if (usuario.nivel === 'gerente') {
    // Verificar se está acessando recursos de sua própria empresa
    if (documento && documento.empresaId !== usuario.empresaId) {
      const result: AuthorizationResult = {
        permitido: false,
        motivo: 'Gerente só pode acessar recursos de sua própria empresa',
        metadata: {
          usuario: usuario.email,
          nivel: usuario.nivel,
          acao,
          recurso: documento.tipo,
          timestamp,
        },
      };
      
      logAuthorization({
        timestamp,
        usuario: {
          id: usuario.id,
          email: usuario.email,
          nivel: usuario.nivel,
        },
        acao,
        recurso: {
          tipo: documento.tipo,
          id: documento.id,
          estado: documento.estado,
        },
        resultado: 'NEGADO',
        motivo: result.motivo,
      });
      
      return result;
    }
    
    // Gerente tem todas as permissões configuradas
    // Continuar para verificação de permissões específicas
  }
  
  // ========== REGRA 4: VERIFICAR PERMISSÃO GRANULAR (PRIORIDADE) ==========
  
  // ✅ NOVO: Verificar permissões granulares ANTES das genéricas
  // ✅ FIX: Verificar granular mesmo sem documento completo (apenas tipo)
  let permissaoGranularPermitida = false; // Flag para indicar que permissão granular foi verificada e permitida
  
  if (documento?.tipo || acao === 'criar') {
    const tipoDocumento = documento?.tipo;
    const permissaoGranular = verificarPermissaoGranular(usuario, acao, tipoDocumento);
    
    // Se há permissão granular configurada, ela tem PRIORIDADE
    if (permissaoGranular !== null) {
      if (permissaoGranular === false) {
        // Negado pela permissão granular
        const result: AuthorizationResult = {
          permitido: false,
          motivo: `Permissão granular: usuário não pode '${acao}' documento '${tipoDocumento}'`,
          metadata: {
            usuario: usuario.email,
            nivel: usuario.nivel,
            acao,
            recurso: tipoDocumento,
            permissaoGranular: 'negada',
            timestamp,
          },
        };
        
        logAuthorization({
          timestamp,
          usuario: {
            id: usuario.id,
            email: usuario.email,
            nivel: usuario.nivel,
          },
          acao,
          recurso: documento ? {
            tipo: documento.tipo,
            id: documento.id,
            estado: documento.estado,
          } : undefined,
          resultado: 'NEGADO',
          motivo: result.motivo,
        });
        
        return result;
      } else {
        // Permitido pela permissão granular
        // Marcar que permissão granular foi permitida
        permissaoGranularPermitida = true;
        
        // ✅ Se for ação CRIAR, retornar PERMITIDO diretamente (não há documento para verificar estado/vínculos)
        if (acao === 'criar' || !documento?.id) {
          const result: AuthorizationResult = {
            permitido: true,
            motivo: `Permissão granular permite '${acao}' documento '${tipoDocumento}'`,
            metadata: {
              usuario: usuario.email,
              nivel: usuario.nivel,
              acao,
              recurso: tipoDocumento,
              permissaoGranular: 'permitida',
              timestamp,
            },
          };
          
          logAuthorization({
            timestamp,
            usuario: {
              id: usuario.id,
              email: usuario.email,
              nivel: usuario.nivel,
            },
            acao,
            recurso: documento ? {
              tipo: documento.tipo,
              id: documento.id || 'novo',
              estado: documento.estado || 'rascunho',
            } : undefined,
            resultado: 'PERMITIDO',
            motivo: result.motivo,
          });
          
          return result;
        }
        
        // Continuar para verificações de estado do documento e vínculos
      }
    } else {
      // Não há permissão granular configurada - usar fallback genérico
      console.log(`⚠️ [can] Permissão granular NÃO CONFIGURADA para ${tipoDocumento}, usando genérica`);
    }
  }
  
  // ========== REGRA 5: VERIFICAR PERMISSÃO BÁSICA (FALLBACK) ==========
  
  const permissaoNecessaria = ACAO_PARA_PERMISSAO[acao];
  
  // ⚠️ IMPORTANTE: Se permissão granular foi permitida, SKIP fallback
  if (!permissaoGranularPermitida) {
    
    // Ações que não requerem permissão específica (ex: visualizar)
    if (permissaoNecessaria === 'bypass') {
      const result: AuthorizationResult = {
        permitido: true,
        motivo: `Ação '${acao}' não requer permissão específica`,
        metadata: {
          usuario: usuario.email,
          nivel: usuario.nivel,
          acao,
          recurso: documento?.tipo,
          timestamp,
        },
      };
      
      logAuthorization({
        timestamp,
        usuario: {
          id: usuario.id,
          email: usuario.email,
          nivel: usuario.nivel,
        },
        acao,
        recurso: documento ? {
          tipo: documento.tipo,
          id: documento.id,
          estado: documento.estado,
        } : undefined,
        resultado: 'PERMITIDO',
        motivo: result.motivo,
      });
      
      return result;
    }
    
    // Verificar se usuário tem a permissão necessária
    if (!usuario.permissoes[permissaoNecessaria]) {
      const result: AuthorizationResult = {
        permitido: false,
        motivo: `Usuário não possui a permissão '${permissaoNecessaria}' necessária para a ação '${acao}'`,
        metadata: {
          usuario: usuario.email,
          nivel: usuario.nivel,
          acao,
          recurso: documento?.tipo,
          timestamp,
        },
      };
      
      logAuthorization({
        timestamp,
        usuario: {
          id: usuario.id,
          email: usuario.email,
          nivel: usuario.nivel,
        },
        acao,
        recurso: documento ? {
          tipo: documento.tipo,
          id: documento.id,
          estado: documento.estado,
        } : undefined,
        resultado: 'NEGADO',
        motivo: result.motivo,
      });
      
      return result;
    }
  }
  
  // ========== REGRA 6: VERIFICAR ESTADO DO DOCUMENTO (SE APLICÁVEL) ==========
  
  if (documento && (acao === 'editar' || acao === 'deletar' || acao === 'anular')) {
    const estado = documento.estado as EstadoDocumento;
    
    // Verificar se documento está bloqueado
    const estaBloqueado = ESTADOS_BLOQUEADOS.includes(estado);
    
    if (estaBloqueado) {
      // Para editar documento bloqueado, precisa de permissão especial
      if (acao === 'editar' && !usuario.permissoes.editarDocumentoEmitido) {
        const result: AuthorizationResult = {
          permitido: false,
          motivo: `Documento está no estado '${estado}' e requer permissão especial 'editarDocumentoEmitido'`,
          metadata: {
            usuario: usuario.email,
            nivel: usuario.nivel,
            acao,
            recurso: documento.tipo,
            timestamp,
          },
        };
        
        logAuthorization({
          timestamp,
          usuario: {
            id: usuario.id,
            email: usuario.email,
            nivel: usuario.nivel,
          },
          acao,
          recurso: {
            tipo: documento.tipo,
            id: documento.id,
            estado: documento.estado,
          },
          resultado: 'NEGADO',
          motivo: result.motivo,
        });
        
        return result;
      }
      
      // Deletar documento bloqueado é sempre negado (exceto Super Admin)
      if (acao === 'deletar') {
        const result: AuthorizationResult = {
          permitido: false,
          motivo: `Documento no estado '${estado}' não pode ser deletado`,
          metadata: {
            usuario: usuario.email,
            nivel: usuario.nivel,
            acao,
            recurso: documento.tipo,
            timestamp,
          },
        };
        
        logAuthorization({
          timestamp,
          usuario: {
            id: usuario.id,
            email: usuario.email,
            nivel: usuario.nivel,
          },
          acao,
          recurso: {
            tipo: documento.tipo,
            id: documento.id,
            estado: documento.estado,
          },
          resultado: 'NEGADO',
          motivo: result.motivo,
        });
        
        return result;
      }
    }
    
    // ========== REGRA 7: VERIFICAR VÍNCULOS ==========
    
    if (acao === 'deletar' || acao === 'editar') {
      const temVinculos = await verificarVinculos(documento);
      
      if (temVinculos) {
        const result: AuthorizationResult = {
          permitido: false,
          motivo: 'Documento possui vínculos com outros documentos e não pode ser modificado',
          metadata: {
            usuario: usuario.email,
            nivel: usuario.nivel,
            acao,
            recurso: documento.tipo,
            timestamp,
          },
        };
        
        logAuthorization({
          timestamp,
          usuario: {
            id: usuario.id,
            email: usuario.email,
            nivel: usuario.nivel,
          },
          acao,
          recurso: {
            tipo: documento.tipo,
            id: documento.id,
            estado: documento.estado,
          },
          resultado: 'NEGADO',
          motivo: result.motivo,
        });
        
        return result;
      }
    }
  }
  
  // ========== REGRA FINAL: PERMITIR ==========
  
  const result: AuthorizationResult = {
    permitido: true,
    motivo: `Usuário tem permissão '${permissaoNecessaria}' e todas as validações passaram`,
    metadata: {
      usuario: usuario.email,
      nivel: usuario.nivel,
      acao,
      recurso: documento?.tipo,
      timestamp,
    },
  };
  
  logAuthorization({
    timestamp,
    usuario: {
      id: usuario.id,
      email: usuario.email,
      nivel: usuario.nivel,
    },
    acao,
    recurso: documento ? {
      tipo: documento.tipo,
      id: documento.id,
      estado: documento.estado,
    } : undefined,
    resultado: 'PERMITIDO',
    motivo: result.motivo,
  });
  
  return result;
}

// ========== FUNÇÕES DE MAPEAMENTO ==========

/**
 * Mapeia tipo de documento para estrutura de permissões granulares
 */
function mapearTipoParaPermissao(tipo: string): { modulo: string; documento: string } | null {
  const mapeamentos: Record<string, { modulo: string; documento: string }> = {
    // Faturação
    'cotacao': { modulo: 'faturacao', documento: 'cotacao' },
    'factura': { modulo: 'faturacao', documento: 'factura' },
    'recibo': { modulo: 'faturacao', documento: 'recibo' },
    'nota-credito': { modulo: 'faturacao', documento: 'notaCredito' },
    'nota-debito': { modulo: 'faturacao', documento: 'notaDebito' },
    'vd': { modulo: 'faturacao', documento: 'vd' },
    
    // Vendas
    'adiantamento': { modulo: 'vendas', documento: 'adiantamento' },
    'venda-dinheiro': { modulo: 'vendas', documento: 'vendaDinheiro' },
    
    // Compras
    'entrada-fornecedor': { modulo: 'compras', documento: 'entradaFornecedor' },
    'nota-credito-compra': { modulo: 'compras', documento: 'notaCreditoCompra' },
    'encomenda-fornecedor': { modulo: 'compras', documento: 'encomendaFornecedor' },
    
    // Stock
    'inventario': { modulo: 'stock', documento: 'inventario' },
    'movimento': { modulo: 'stock', documento: 'movimentos' },
    'guia-remessa': { modulo: 'stock', documento: 'guiasRemessa' },
    'transferencia': { modulo: 'stock', documento: 'transferencias' },
    
    // Terceiros
    'cliente': { modulo: 'terceiros', documento: 'clientes' },
    'fornecedor': { modulo: 'terceiros', documento: 'fornecedores' },
    'artigo': { modulo: 'terceiros', documento: 'artigos' },
    'armazem': { modulo: 'terceiros', documento: 'armazens' },
  };
  
  return mapeamentos[tipo.toLowerCase()] || null;
}

/**
 * Mapeia Action para AcaoDocumento
 */
function mapearAcaoParaAcaoDocumento(acao: Action): AcaoDocumento | null {
  const mapeamento: Record<Action, AcaoDocumento | null> = {
    'criar': 'criar',
    'editar': 'editar',
    'deletar': 'deletar',
    'anular': 'anular',
    'visualizar': 'visualizar',
    'aprovar': 'editar',
    'rejeitar': 'editar',
    'emitir': 'editar',
    'exportar-saft': null,
    'gerenciar-usuarios': null,
    'configurar-empresa': null,
    'visualizar-logs': null,
    'conceder-permissoes': null,
  };
  
  return mapeamento[acao] || null;
}

/**
 * Verificar permissão granular por módulo/documento/ação
 * Retorna true se permitido, false se negado, null se não há permissão granular configurada
 */
function verificarPermissaoGranular(
  usuario: Usuario,
  acao: Action,
  tipo?: string
): boolean | null {
  // ✅ FASE 4 FIX: Suporte a AMBOS os formatos (permissoesModulos e permissoesGranulares)
  const permissoesGranulares = (usuario as any).permissoesGranulares || usuario.permissoesModulos;
  
  // Se não tem permissões granulares configuradas, retornar null
  if (!permissoesGranulares || !tipo) {
    return null;
  }
  
  // Mapear tipo para módulo/documento
  const mapeamento = mapearTipoParaPermissao(tipo);
  if (!mapeamento) {
    return null; // Tipo não mapeado, usar permissões genéricas
  }
  
  // Mapear ação para ação de documento
  const acaoDoc = mapearAcaoParaAcaoDocumento(acao);
  if (!acaoDoc) {
    return null; // Ação não mapeada, usar permissões genéricas
  }
  
  // Navegar pela estrutura de permissões granulares
  const moduloPermissoes = permissoesGranulares[mapeamento.modulo];
  if (!moduloPermissoes) {
    return null;
  }
  
  const documentoPermissoes = (moduloPermissoes as any)[mapeamento.documento];
  if (!documentoPermissoes) {
    return null;
  }
  
  const permitido = documentoPermissoes[acaoDoc];
  if (typeof permitido !== 'boolean') {
    return null;
  }
  
  console.log(`🔍 [verificarPermissaoGranular] ${usuario.email} → ${mapeamento.modulo}.${mapeamento.documento}.${acaoDoc} = ${permitido}`);
  
  return permitido;
}

// ========== FUNÇÕES AUXILIARES ==========

/**
 * Verificar se documento possui vínculos com outros documentos
 */
async function verificarVinculos(documento: Documento): Promise<boolean> {
  const supabase = createClient(supabaseUrl, supabaseServiceKey);
  
  try {
    // Verificar recibos vinculados a facturas
    // ✅ Recibo.pagamentos é um array de { facturaId, ... } — não existe (nunca existiu)
    // um campo "facturasVinculadas" nos recibos, por isso este filtro nunca encontrava
    // nada. A verificação real de pagamento já é feita em facturas.calcularTotalPagoFactura,
    // mas esta camada de defesa-em-profundidade ficava sempre a dizer "sem vínculos".
    if (documento.tipo === 'factura') {
      const { data: recibos } = await supabase
        .from('kv_store_7249dcd9')
        .select('key')
        .like('key', `recibo:${documento.empresaId}:%`)
        .contains('value->pagamentos', [{ facturaId: documento.id }])
        .limit(1);

      if (recibos && recibos.length > 0) {
        return true;
      }
    }

    // Verificar facturas vinculadas a cotações
    if (documento.tipo === 'cotacao') {
      const { data: facturas } = await supabase
        .from('kv_store_7249dcd9')
        .select('key')
        .like('key', `factura:${documento.empresaId}:%`)
        .eq('value->>cotacaoId', documento.id)
        .limit(1);

      if (facturas && facturas.length > 0) {
        return true;
      }
    }

    return false;
  } catch (error) {
    console.error('[verificarVinculos] ❌ Erro:', error);
    return true; // Por segurança, assumir que tem vínculos em caso de erro
  }
}

// ========== FUNÇÕES DE CONVENIÊNCIA ==========

/**
 * Verificar se usuário pode criar documento
 */
export async function canCreate(usuario: Usuario, tipo: string): Promise<AuthorizationResult> {
  return can(usuario, 'criar', { tipo } as Documento);
}

/**
 * Verificar se usuário pode editar documento
 */
export async function canEdit(usuario: Usuario, documento: Documento): Promise<AuthorizationResult> {
  return can(usuario, 'editar', documento);
}

/**
 * Verificar se usuário pode visualizar documento
 */
export async function canView(usuario: Usuario, documento: Documento): Promise<AuthorizationResult> {
  return can(usuario, 'visualizar', documento);
}

/**
 * Verificar se usuário pode deletar documento
 */
export async function canDelete(usuario: Usuario, documento: Documento): Promise<AuthorizationResult> {
  return can(usuario, 'deletar', documento);
}

/**
 * Verificar se usuário pode anular documento
 */
export async function canCancel(usuario: Usuario, documento: Documento): Promise<AuthorizationResult> {
  return can(usuario, 'anular', documento);
}

/**
 * Verificar se usuário pode aprovar documento
 */
export async function canApprove(usuario: Usuario, documento: Documento): Promise<AuthorizationResult> {
  return can(usuario, 'aprovar', documento);
}

/**
 * Verificar se usuário pode rejeitar documento
 */
export async function canReject(usuario: Usuario, documento: Documento): Promise<AuthorizationResult> {
  return can(usuario, 'rejeitar', documento);
}

/**
 * Verificar se usuário pode exportar SAFT
 */
export async function canExportSAFT(usuario: Usuario): Promise<AuthorizationResult> {
  return can(usuario, 'exportar-saft');
}

/**
 * Verificar se usuário pode gerenciar outros usuários
 */
export async function canManageUsers(usuario: Usuario): Promise<AuthorizationResult> {
  return can(usuario, 'gerenciar-usuarios');
}

/**
 * Verificar se usuário pode configurar empresa
 */
export async function canConfigureCompany(usuario: Usuario): Promise<AuthorizationResult> {
  return can(usuario, 'configurar-empresa');
}

/**
 * Verificar se usuário pode visualizar logs
 */
export async function canViewLogs(usuario: Usuario): Promise<AuthorizationResult> {
  return can(usuario, 'visualizar-logs');
}