import { NextRequest, NextResponse } from 'next/server'
import { getServerSession } from 'next-auth'
import { authOptions } from '@/lib/auth'
import { prisma } from '@/lib/prisma'
import { buscarProcessoTribunal, isError } from '@/lib/tribunal-client'

// POST /api/processos/[id]/atualizar
// Busca dados em tempo real do tribunal via scraping
export async function POST(
  req: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  const session = await getServerSession(authOptions)
  if (!session?.user?.id) {
    return NextResponse.json({ error: 'Não autorizado' }, { status: 401 })
  }

  const { id } = await params

  // Buscar processo no banco
  const processo = await prisma.processoMonitorado.findFirst({
    where: {
      id,
      userId: session.user.id,
    },
  })

  if (!processo) {
    return NextResponse.json({ error: 'Processo não encontrado' }, { status: 404 })
  }

  try {
    // Buscar dados em tempo real via tribunal-api
    console.log(`[Atualizar] Buscando ${processo.numeroProcesso} via tribunal-api...`)
    const resultado = await buscarProcessoTribunal(processo.numeroProcesso)

    if (isError(resultado)) {
      return NextResponse.json({
        error: resultado.erro,
        codigo: resultado.codigo,
        detalhes: resultado.detalhes,
      }, { status: resultado.codigo === 'PROCESSO_NAO_ENCONTRADO' ? 404 : 503 })
    }

    // Atualizar dados do processo no banco
    const updated = await prisma.processoMonitorado.update({
      where: { id },
      data: {
        vara: resultado.vara || processo.vara,
        comarca: resultado.comarca || processo.comarca,
        classe: resultado.classe || processo.classe,
        assunto: resultado.assunto || processo.assunto,
        ultimaAtualizacao: new Date(),
      },
    })

    // Salvar novos andamentos se existirem
    let novosAndamentos = 0
    if (resultado.movimentos && resultado.movimentos.length > 0) {
      for (let i = 0; i < resultado.movimentos.length; i++) {
        const mov = resultado.movimentos[i]
        
        // Converter data DD/MM/YYYY para Date
        const partes = mov.data.split('/')
        if (partes.length !== 3) continue
        
        const [dia, mes, ano] = partes
        const dataHora = new Date(`${ano}-${mes}-${dia}T12:00:00Z`)
        
        if (isNaN(dataHora.getTime())) continue

        // Usar índice como código único para evitar duplicatas
        const codigo = parseInt(ano) * 10000 + parseInt(mes) * 100 + parseInt(dia) + i

        try {
          // Verificar se já existe
          const existe = await prisma.andamento.findFirst({
            where: {
              processoId: id,
              dataHora,
              nome: mov.descricao.substring(0, 200),
            },
          })

          if (!existe) {
            await prisma.andamento.create({
              data: {
                processoId: id,
                dataHora,
                codigo,
                nome: mov.descricao.substring(0, 200),
                complemento: mov.descricao.length > 200 ? mov.descricao : null,
              },
            })
            novosAndamentos++
          }
        } catch (e) {
          // Ignorar duplicatas (unique constraint)
          console.log('[Atualizar] Andamento duplicado, ignorando')
        }
      }
    }

    // Buscar andamentos atualizados
    const andamentos = await prisma.andamento.findMany({
      where: { processoId: id },
      orderBy: { dataHora: 'desc' },
      take: 50,
    })

    return NextResponse.json({
      success: true,
      processo: updated,
      andamentos,
      novosAndamentos,
      fonte: 'tribunal-api',
      tribunal: resultado.tribunal,
      ultimaAtualizacao: resultado.ultimaAtualizacao,
    })

  } catch (error) {
    console.error('[Atualizar] Erro:', error)
    return NextResponse.json({
      error: 'Erro ao atualizar processo',
      detalhes: error instanceof Error ? error.message : 'Erro desconhecido'
    }, { status: 500 })
  }
}
