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

export const runtime = 'edge'

export async function POST(request: NextRequest) {
  try {
    const body = await request.json()
    
    console.log('🔔 Webhook MercadoPago recebido:', body)

    // Validar se é uma notificação de pagamento
    if (body.type === 'payment') {
      const paymentId = body.data?.id
      
      if (!paymentId) {
        console.error('❌ Payment ID não encontrado na notificação')
        return NextResponse.json({ error: 'Payment ID não encontrado' }, { status: 400 })
      }

      // Buscar detalhes do pagamento na API do MercadoPago
      const accessToken = process.env.MERCADO_PAGO_ACCESS_TOKEN
      
      if (!accessToken) {
        console.error('❌ MERCADO_PAGO_ACCESS_TOKEN não configurado')
        return NextResponse.json({ error: 'Token não configurado' }, { status: 500 })
      }

      try {
        console.log(`🔍 Buscando detalhes do pagamento ${paymentId}...`)
        
        const paymentResponse = await fetch(`https://api.mercadopago.com/v1/payments/${paymentId}`, {
          headers: {
            'Authorization': `Bearer ${accessToken}`,
            'Content-Type': 'application/json',
          }
        })

        if (!paymentResponse.ok) {
          const errorText = await paymentResponse.text()
          console.error('❌ Erro ao buscar pagamento:', errorText)
          return NextResponse.json({ error: 'Erro ao buscar pagamento' }, { status: 500 })
        }

        const payment = await paymentResponse.json()
        
        console.log('💳 Detalhes do pagamento:', {
          id: payment.id,
          status: payment.status,
          external_reference: payment.external_reference,
          transaction_amount: payment.transaction_amount
        })

        // Processar com base no status do pagamento
        const pedidoId = payment.external_reference
        
        if (!pedidoId) {
          console.error('❌ Pedido ID não encontrado no external_reference')
          return NextResponse.json({ error: 'Pedido não identificado' }, { status: 400 })
        }

        // Atualizar status do pedido baseado no status do pagamento
        let novoStatus = ''
        let mensagem = ''

        switch (payment.status) {
          case 'approved':
            novoStatus = 'pago'
            mensagem = `Pagamento aprovado via MercadoPago. ID: ${paymentId}`
            console.log('✅ Pagamento aprovado!')
            break
          case 'pending':
          case 'in_process':
            novoStatus = 'aguardando_pagamento'
            mensagem = `Pagamento pendente no MercadoPago. ID: ${paymentId}`
            console.log('⏳ Pagamento pendente')
            break
          case 'rejected':
          case 'cancelled':
            novoStatus = 'cancelado'
            mensagem = `Pagamento rejeitado/cancelado no MercadoPago. ID: ${paymentId}`
            console.log('❌ Pagamento rejeitado/cancelado')
            break
          default:
            console.log(`⚠️ Status desconhecido: ${payment.status}`)
            return NextResponse.json({ message: 'Status processado' })
        }

        // Atualizar pedido no sistema
        try {
          console.log(`📝 Atualizando pedido ${pedidoId} para status: ${novoStatus}`)
          
          const updateResult = await pedidoService.atualizarPedido(pedidoId, {
            status: novoStatus,
            'dados-pagamento': {
              metodo: 'mercadopago',
              status: payment.status,
              payment_id: paymentId,
              transaction_amount: payment.transaction_amount,
              payment_method_id: payment.payment_method_id,
              payment_type_id: payment.payment_type_id,
              date_approved: payment.date_approved,
              date_created: payment.date_created,
              external_reference: payment.external_reference
            },
            observacoes: mensagem
          })

          if (updateResult.success) {
            console.log('✅ Pedido atualizado com sucesso!')
          } else {
            console.error('❌ Erro ao atualizar pedido:', updateResult.error)
          }

        } catch (updateError) {
          console.error('❌ Erro ao atualizar pedido:', updateError)
        }

        return NextResponse.json({ 
          message: 'Webhook processado com sucesso',
          payment_id: paymentId,
          status: payment.status,
          pedido_id: pedidoId
        })

      } catch (fetchError) {
        console.error('❌ Erro ao buscar pagamento:', fetchError)
        return NextResponse.json({ error: 'Erro ao processar webhook' }, { status: 500 })
      }
    }

    // Para outros tipos de notificação, apenas confirmar recebimento
    console.log(`ℹ️ Tipo de notificação não processada: ${body.type}`)
    return NextResponse.json({ message: 'Notificação recebida' })

  } catch (error) {
    console.error('❌ Erro geral no webhook:', error)
    return NextResponse.json(
      { error: 'Erro interno do servidor' },
      { status: 500 }
    )
  }
}
export async function GET() {
  return NextResponse.json({ 
    message: 'Webhook MercadoPago ativo',
    timestamp: new Date().toISOString()
  })
}
