import { NextRequest, NextResponse } from 'next/server'
import { getServerSession } from 'next-auth'
import { authOptions } from '@/lib/auth'
import { prisma } from '@/lib/prisma'
import { validarNumeroCNJ } from '@/lib/publicacoes-service'
import { buscarProcessoCompleto } from '@/lib/diarios-service'

export async function GET(req: NextRequest) {
  const session = await getServerSession(authOptions)
  if (!session?.user?.id) {
    return NextResponse.json({ error: 'Não autorizado' }, { status: 401 })
  }

  const { searchParams } = new URL(req.url)
  const status = searchParams.get('status')

  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const where: any = { userId: session.user.id }
  if (status) where.status = status

  const processos = await prisma.processoMonitorado.findMany({
    where,
    orderBy: { createdAt: 'desc' },
    include: {
      _count: {
        select: {
          publicacoes: {
            where: { visualizado: false }
          }
        }
      },
      publicacoes: {
        orderBy: { dataPublicacao: 'desc' },
        take: 1,
      },
      andamentos: {
        orderBy: { dataHora: 'desc' },
        take: 1,
      }
    }
  })

  // Formata resposta com contagem de não lidas
  const result = processos.map(p => ({
    ...p,
    publicacoesNaoLidas: p._count.publicacoes,
    ultimaPublicacao: p.publicacoes[0] || null,
    ultimoAndamento: p.andamentos[0] || null,
    publicacoes: undefined,
    andamentos: undefined,
    _count: undefined,
  }))

  return NextResponse.json({ processos: result })
}

export async function POST(req: NextRequest) {
  const session = await getServerSession(authOptions)
  if (!session?.user?.id) {
    return NextResponse.json({ error: 'Não autorizado' }, { status: 401 })
  }

  const body = await req.json()
  const { numeroProcesso, tribunal, vara, comarca, parteAutora, parteRe } = body

  // Validações
  if (!numeroProcesso || !tribunal) {
    return NextResponse.json(
      { error: 'Número do processo e tribunal são obrigatórios' },
      { status: 400 }
    )
  }

  if (!validarNumeroCNJ(numeroProcesso)) {
    return NextResponse.json(
      { error: 'Número do processo inválido. Use o formato CNJ: 0000000-00.0000.0.00.0000' },
      { status: 400 }
    )
  }

  // Verifica se já existe
  const existing = await prisma.processoMonitorado.findFirst({
    where: {
      userId: session.user.id,
      numeroProcesso,
    }
  })

  if (existing) {
    return NextResponse.json(
      { error: 'Este processo já está sendo monitorado' },
      { status: 400 }
    )
  }

  // Criar processo primeiro
  const processo = await prisma.processoMonitorado.create({
    data: {
      userId: session.user.id,
      numeroProcesso,
      tribunal,
      vara: vara || null,
      comarca: comarca || null,
      parteAutora: parteAutora || null,
      parteRe: parteRe || null,
      status: 'ATIVO',
    },
  })

  // Buscar dados completos na API DataJud (não bloqueia a criação)
  try {
    const resultado = await buscarProcessoCompleto(numeroProcesso, tribunal)
    
    if (resultado.sucesso && resultado.dados) {
      const dados = resultado.dados
      
      // Atualizar processo com dados da API
      await prisma.processoMonitorado.update({
        where: { id: processo.id },
        data: {
          classe: dados.classe?.nome || null,
          assunto: dados.assuntos?.[0]?.nome || null,
          dataAjuizamento: dados.dataAjuizamento || null,
          orgaoJulgador: dados.orgaoJulgador?.nome || null,
          grau: dados.grau || null,
          ultimaAtualizacao: new Date(),
          dadosCompletos: dados.dadosBrutos || null,
        },
      })
      
      // Salvar andamentos
      if (dados.movimentos && dados.movimentos.length > 0) {
        const andamentosData = dados.movimentos.map(mov => ({
          processoId: processo.id,
          codigo: mov.codigo,
          nome: mov.nome,
          dataHora: mov.dataHora,
          complemento: mov.complementosTabelados?.map(c => c.nome).join(', ') || null,
        }))
        
        // Usar createMany com skipDuplicates para evitar erros
        await prisma.andamento.createMany({
          data: andamentosData,
          skipDuplicates: true,
        })
      }
      
      console.log(`[Processos] Dados completos salvos para ${numeroProcesso}`)
    }
  } catch (error) {
    console.error(`[Processos] Erro ao buscar dados completos para ${numeroProcesso}:`, error)
    // Não falha a criação se a busca de dados falhar
  }

  // Retornar processo atualizado
  const processoAtualizado = await prisma.processoMonitorado.findUnique({
    where: { id: processo.id },
    include: {
      andamentos: {
        orderBy: { dataHora: 'desc' },
        take: 5,
      }
    }
  })

  return NextResponse.json({ processo: processoAtualizado }, { status: 201 })
}
