import { NextRequest, NextResponse } from 'next/server';
import prisma from '@/lib/prisma';
import { cookies } from 'next/headers';
import jwt from 'jsonwebtoken';

async function authenticate() {
    const cookieStore = await cookies();
    const token = cookieStore.get('auth_token')?.value;

    if (!token) return null;

    try {
        const decoded = jwt.verify(token, process.env.JWT_SECRET!) as { userId: string };
        const user = await prisma.user.findUnique({
            where: { id: decoded.userId },
            select: { id: true, email: true, name: true }
        });
        return user;
    } catch {
        return null;
    }
}

// GET /api/admin/backup - Exportar todos os dados do CMS
export async function GET() {
    try {
        const user = await authenticate();
        if (!user) {
            return NextResponse.json({ error: 'Não autorizado' }, { status: 401 });
        }

        const projects = await prisma.project.findMany();
        const services = await prisma.service.findMany();
        const pageContents = await prisma.pageContent.findMany();
        const settings = await prisma.settings.findFirst();

        const backupData = {
            version: '1.0',
            timestamp: new Date().toISOString(),
            projects,
            services,
            pageContents,
            settings,
        };

        return NextResponse.json(backupData);
    } catch (error) {
        console.error('Erro ao exportar backup:', error);
        return NextResponse.json({ error: 'Erro ao processar exportação' }, { status: 500 });
    }
}

// POST /api/admin/backup - Importar dados do CMS
export async function POST(request: NextRequest) {
    try {
        const user = await authenticate();
        if (!user) {
            return NextResponse.json({ error: 'Não autorizado' }, { status: 401 });
        }

        const backupData = await request.json();

        if (!backupData || typeof backupData !== 'object') {
            return NextResponse.json({ error: 'Dados de backup inválidos' }, { status: 400 });
        }

        // Usar transação para garantir consistência
        await prisma.$transaction(async (tx) => {
            // 1. Importar Projetos
            if (Array.isArray(backupData.projects)) {
                for (const project of backupData.projects) {
                    const { id, createdAt, updatedAt, ...data } = project;
                    await tx.project.upsert({
                        where: { id: id },
                        create: { id, ...data },
                        update: data,
                    });
                }
            }

            // 2. Importar Serviços
            if (Array.isArray(backupData.services)) {
                for (const service of backupData.services) {
                    const { id, createdAt, updatedAt, ...data } = service;
                    await tx.service.upsert({
                        where: { id: id },
                        create: { id, ...data },
                        update: data,
                    });
                }
            }

            // 3. Importar Conteúdo de Páginas
            if (Array.isArray(backupData.pageContents)) {
                for (const content of backupData.pageContents) {
                    const { id, updatedAt, ...data } = content;
                    await tx.pageContent.upsert({
                        where: { slug_locale: { slug: data.slug, locale: data.locale } },
                        create: { ...data },
                        update: data,
                    });
                }
            }

            // 4. Importar Configurações
            if (backupData.settings) {
                const { id, updatedAt, ...data } = backupData.settings;
                const currentSettings = await tx.settings.findFirst();

                if (currentSettings) {
                    await tx.settings.update({
                        where: { id: currentSettings.id },
                        data: data,
                    });
                } else {
                    await tx.settings.create({
                        data: data,
                    });
                }
            }
        });

        return NextResponse.json({
            success: true,
            message: 'Backup importado com sucesso!'
        });
    } catch (error) {
        console.error('Erro ao importar backup:', error);
        return NextResponse.json({
            error: 'Erro ao processar importação. Verifique se o formato do arquivo é válido.'
        }, { status: 500 });
    }
}