import { NextRequest, NextResponse } from 'next/server';
import { getServerSession } from 'next-auth';
import { authOptions } from '../../auth/[...nextauth]/route';
import { PrismaClient } from '@prisma/client';
import bcrypt from 'bcryptjs';

const prisma = new PrismaClient();

// Get user profile
export async function GET(request: NextRequest) {
    const session = await getServerSession(authOptions);
    if (!session?.user?.email) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });

    const user = await prisma.user.findUnique({
        where: { email: session.user.email },
        select: {
            name: true,
            email: true,
            timezone: true,
            autoRolling: true,
            protectEventTimes: true,
            language: true,
            dateFormat: true,
            timeFormat: true,
            startHour: true,
            endHour: true,
            showNextTask: true,
            calendarEditMode: true,
            focusTimerDuration: true,
            showTimeGrid: true,
            cellDuration: true,
            viewStyle: true,
            fontSize: true,
            createdAt: true
        }
    });

    if (!user) {
        return NextResponse.json({ error: 'User not found' }, { status: 404 });
    }

    return NextResponse.json({ user });
}

// Update user profile
export async function PATCH(request: NextRequest) {
    const session = await getServerSession(authOptions);

    if (!session || !session.user?.email) {
        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }

    try {
        const body = await request.json();
        const {
            name, timezone, password, autoRolling, protectEventTimes,
            language, dateFormat, timeFormat, startHour, endHour,
            showNextTask, calendarEditMode, focusTimerDuration,
            showTimeGrid, cellDuration, viewStyle, fontSize
        } = body;

        const updateData: any = {
            ...(name !== undefined && { name }),
            ...(timezone !== undefined && { timezone }),
            ...(autoRolling !== undefined && { autoRolling }),
            ...(protectEventTimes !== undefined && { protectEventTimes }),
            ...(language !== undefined && { language }),
            ...(dateFormat !== undefined && { dateFormat }),
            ...(timeFormat !== undefined && { timeFormat }),
            ...(startHour !== undefined && !isNaN(startHour) && { startHour }),
            ...(endHour !== undefined && !isNaN(endHour) && { endHour }),
            ...(showNextTask !== undefined && { showNextTask }),
            ...(calendarEditMode !== undefined && { calendarEditMode }),
            ...(focusTimerDuration !== undefined && !isNaN(focusTimerDuration) && { focusTimerDuration }),
            ...(showTimeGrid !== undefined && { showTimeGrid }),
            ...(cellDuration !== undefined && !isNaN(cellDuration) && { cellDuration }),
            ...(viewStyle !== undefined && { viewStyle }),
            ...(fontSize !== undefined && { fontSize }),
        };
        if (password && password.trim() !== "") {
            updateData.passwordHash = await bcrypt.hash(password, 10);
        }

        const user = await prisma.user.update({
            where: { email: session.user.email },
            data: updateData,
            select: {
                id: true,
                name: true,
                email: true,
                timezone: true,
                autoRolling: true,
                protectEventTimes: true,
                language: true,
                dateFormat: true,
                timeFormat: true,
                startHour: true,
                endHour: true,
                showNextTask: true,
                calendarEditMode: true,
                focusTimerDuration: true,
                showTimeGrid: true,
                cellDuration: true,
                viewStyle: true,
                fontSize: true,
            }
        });

        return NextResponse.json({ success: true, user });
    } catch (e) {
        console.error('Error updating profile:', e);
        return NextResponse.json(
            { error: 'Failed to update profile', details: (e as Error).message },
            { status: 500 }
        );
    }
}

// Delete account
export async function DELETE(request: NextRequest) {
    const session = await getServerSession(authOptions);
    if (!session?.user?.email) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });

    try {
        await prisma.user.delete({
            where: { email: session.user.email }
        });
        return NextResponse.json({ success: true });
    } catch (error) {
        console.error('Error deleting account:', error);
        return NextResponse.json({ error: 'Failed to delete account' }, { status: 500 });
    }
}