import { NextRequest, NextResponse } from 'next/server';
import { pagamentoService } from '@/services/pagamentoService';
import { pedidoService } from '@/services/pedidoService';
import { faturaService } from '@/services/faturaService';

// Configuração para usar Edge Runtime (necessário para Cloudflare Pages)
export const runtime = 'edge';

// Webhook para receber atualizações de status do gateway de pagamento
export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    
    // Validar se os dados necessários estão presentes
    const { pagamentoId, status, transacaoId, gatewayResponse } = body;
    
    if (!pagamentoId || !status) {
      return NextResponse.json(
        { error: 'Dados obrigatórios não fornecidos' },
        { status: 400 }
      );
    }

    console.log('Webhook recebido:', { pagamentoId, status, transacaoId });

    // Buscar o pagamento existente
    const pagamento = await pagamentoService.buscarPorId(pagamentoId);
    
    if (!pagamento) {
      return NextResponse.json(
        { error: 'Pagamento não encontrado' },
        { status: 404 }
      );
    }

    // Atualizar status do pagamento
    const dadosAtualizacao: any = {
      status: status,
    };

    // Adicionar dados adicionais se fornecidos
    if (transacaoId) {
      dadosAtualizacao.transacaoId = transacaoId;
    }
    if (gatewayResponse) {
      dadosAtualizacao.gatewayResponse = JSON.stringify(gatewayResponse);
    }

    await pagamentoService.atualizar(pagamentoId, dadosAtualizacao);
    console.log(`Status do pagamento ${pagamentoId} atualizado para: ${status}`);

    // Atualizar status do pedido baseado no status do pagamento
    if (pagamento.pedidos) {
      let statusPedido = '';
      
      switch (status) {
        case 'pago':
        case 'aprovado':
          statusPedido = 'aprovado';
          break;
        case 'falhou':
        case 'cancelado':
        case 'rejeitado':
          statusPedido = 'cancelado';
          break;
        case 'pendente':
        case 'processando':
          statusPedido = 'pendente';
          break;
        default:
          statusPedido = 'pendente';
      }

      if (statusPedido) {
        try {
          await pedidoService.atualizarParcial(pagamento.pedidos, { status: statusPedido });
          console.log(`Status do pedido ${pagamento.pedidos} atualizado para: ${statusPedido}`);
        } catch (error) {
          console.error('Erro ao atualizar status do pedido:', error);
        }
      }
    }

    // Atualizar status da fatura se existir
    if (pagamento.faturas) {
      let statusFatura = '';
      
      switch (status) {
        case 'pago':
        case 'aprovado':
          statusFatura = 'pago';
          break;
        case 'falhou':
        case 'cancelado':
        case 'rejeitado':
          statusFatura = 'cancelada';
          break;
        default:
          statusFatura = 'pendente';
      }

      if (statusFatura) {
        try {
          await faturaService.atualizarFaturaParcial(pagamento.faturas, { status: statusFatura });
          console.log(`Status da fatura ${pagamento.faturas} atualizado para: ${statusFatura}`);
        } catch (error) {
          console.error('Erro ao atualizar status da fatura:', error);
        }
      }
    }

    return NextResponse.json(
      { 
        success: true, 
        message: 'Webhook processado com sucesso',
        pagamentoId,
        novoStatus: status
      },
      { status: 200 }
    );

  } catch (error) {
    console.error('Erro ao processar webhook de pagamento:', error);
    return NextResponse.json(
      { error: 'Erro interno do servidor' },
      { status: 500 }
    );
  }
}

// Método GET para verificar se o endpoint está funcionando
export async function GET() {
  return NextResponse.json(
    { 
      message: 'Webhook de pagamento ativo',
      timestamp: new Date().toISOString()
    },
    { status: 200 }
  );
}