/**
 * API de Avatar
 * POST - Faz upload de uma nova foto de perfil
 * DELETE - Remove a foto de perfil (volta ao padrão)
 */

import { NextRequest, NextResponse } from "next/server"
import { headers } from "next/headers"

import { getServerSession } from "@/lib/auth-server"
import { auth } from "@/lib/auth"
import { prisma } from "@/lib/prisma"
import { DEFAULT_TENANT_ID } from "@/lib/constants"
import { createConvexClient } from "@/server/convex-client"
import { api } from "@/convex/_generated/api"
import type { Id } from "@/convex/_generated/dataModel"

const MAX_FILE_SIZE = 5 * 1024 * 1024 // 5MB
const ALLOWED_TYPES = ["image/jpeg", "image/png", "image/webp", "image/gif"]

export async function POST(request: NextRequest) {
  try {
    const session = await getServerSession()

    if (!session?.user?.id) {
      return NextResponse.json({ error: "Não autorizado" }, { status: 401 })
    }

    const formData = await request.formData()
    const file = formData.get("file") as File | null

    if (!file) {
      return NextResponse.json({ error: "Nenhum arquivo enviado" }, { status: 400 })
    }

    // Valida tipo
    if (!ALLOWED_TYPES.includes(file.type)) {
      return NextResponse.json(
        { error: "Tipo de arquivo não permitido. Use JPG, PNG, WebP ou GIF." },
        { status: 400 }
      )
    }

    // Valida tamanho
    if (file.size > MAX_FILE_SIZE) {
      return NextResponse.json(
        { error: "Arquivo muito grande. Máximo 5MB." },
        { status: 400 }
      )
    }

    const convex = createConvexClient()

    // Gera URL de upload
    const uploadUrl = await convex.action(api.files.generateUploadUrl, {})

    // Faz upload do arquivo
    const uploadResponse = await fetch(uploadUrl, {
      method: "POST",
      headers: { "Content-Type": file.type },
      body: file,
    })

    if (!uploadResponse.ok) {
      console.error("[profile/avatar] Erro no upload:", await uploadResponse.text())
      return NextResponse.json({ error: "Erro ao fazer upload" }, { status: 500 })
    }

    const { storageId } = (await uploadResponse.json()) as { storageId: Id<"_storage"> }

    // Obtém URL pública do arquivo
    const avatarUrl = await convex.action(api.files.getUrl, { storageId })

    if (!avatarUrl) {
      return NextResponse.json({ error: "Erro ao obter URL do avatar" }, { status: 500 })
    }

    // Usa updateUser do Better Auth para invalidar o cache da sessao
    const headerList = await headers()
    const updateResult = await auth.api.updateUser({
      headers: headerList,
      body: { avatarUrl },
    })

    if (!updateResult) {
      // Fallback: atualiza diretamente no Prisma
      await prisma.authUser.update({
        where: { id: session.user.id },
        data: { avatarUrl },
      })
    }

    // Sincroniza com o Convex
    try {
      const tenantId = session.user.tenantId ?? DEFAULT_TENANT_ID
      await convex.mutation(api.users.updateAvatar, {
        tenantId,
        email: session.user.email,
        avatarUrl,
      })
    } catch (error) {
      console.warn("[profile/avatar] Falha ao sincronizar avatar no Convex:", error)
    }

    return NextResponse.json({
      success: true,
      avatarUrl,
    })
  } catch (error) {
    console.error("[profile/avatar] Erro:", error)
    return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 })
  }
}

export async function DELETE() {
  try {
    const session = await getServerSession()

    if (!session?.user?.id) {
      return NextResponse.json({ error: "Não autorizado" }, { status: 401 })
    }

    // Usa updateUser do Better Auth para invalidar o cache da sessao
    const headerList = await headers()
    const updateResult = await auth.api.updateUser({
      headers: headerList,
      body: { avatarUrl: null },
    })

    if (!updateResult) {
      // Fallback: atualiza diretamente no Prisma
      await prisma.authUser.update({
        where: { id: session.user.id },
        data: { avatarUrl: null },
      })
    }

    // Sincroniza com o Convex
    try {
      const convex = createConvexClient()
      const tenantId = session.user.tenantId ?? DEFAULT_TENANT_ID
      await convex.mutation(api.users.updateAvatar, {
        tenantId,
        email: session.user.email,
        avatarUrl: null,
      })
    } catch (error) {
      console.warn("[profile/avatar] Falha ao sincronizar remoção de avatar no Convex:", error)
    }

    return NextResponse.json({
      success: true,
      message: "Foto removida com sucesso",
    })
  } catch (error) {
    console.error("[profile/avatar] Erro ao remover:", error)
    return NextResponse.json({ error: "Erro interno do servidor" }, { status: 500 })
  }
}

/**
 * PATCH - Força sincronização do avatar atual do Prisma para o Convex
 * Útil quando a sincronização automática falhou
 */
export async function PATCH() {
  try {
    const session = await getServerSession()

    if (!session?.user?.id) {
      return NextResponse.json({ error: "Não autorizado" }, { status: 401 })
    }

    // Busca o avatar atual no Prisma
    const user = await prisma.authUser.findUnique({
      where: { id: session.user.id },
      select: { avatarUrl: true },
    })

    // Sincroniza com o Convex
    const convex = createConvexClient()
    const tenantId = session.user.tenantId ?? DEFAULT_TENANT_ID

    const result = await convex.mutation(api.users.updateAvatar, {
      tenantId,
      email: session.user.email,
      avatarUrl: user?.avatarUrl ?? null,
    })

    console.log("[profile/avatar] Sincronização forçada:", result)

    return NextResponse.json({
      success: true,
      message: "Avatar sincronizado com sucesso",
      avatarUrl: user?.avatarUrl ?? null,
      convexResult: result,
    })
  } catch (error) {
    console.error("[profile/avatar] Erro na sincronização:", error)
    return NextResponse.json({ error: "Erro ao sincronizar avatar" }, { status: 500 })
  }
}
