import { cookies } from "next/headers";
import prisma from "@/lib/prisma";
import { AdminAuthService } from "@/services/AdminAuthService";
import { SESSION_COOKIE_NAME, decryptSession } from "@/lib/session";

export async function getCurrentUser() {
    const cookieStore = await cookies();
    let userId: string | undefined = undefined;

    const adminSessionToken = cookieStore.get("adminSessionToken")?.value;
    const sessionToken = cookieStore.get(SESSION_COOKIE_NAME)?.value;

    // 1. Try Admin Session first
    if (adminSessionToken) {
        const sessionResult = await AdminAuthService.validateSession(adminSessionToken);
        if (sessionResult && sessionResult.session.status === "active") {
            userId = sessionResult.user.id;
        }
    }

    // 2. Fallback to Regular Session if no valid admin session found
    if (!userId && sessionToken) {
        const payload = await decryptSession(sessionToken);
        if (payload?.userId) {
            userId = payload.userId;
        }
    }

    if (!userId) return undefined;

    const user = await prisma.user.findUnique({
        where: { id: userId },
        include: {
            profile: true,
            skills: {
                include: { skill: true }
            },
            experiences: {
                orderBy: { start_date: 'desc' }
            },
            education: {
                orderBy: { end_date: 'desc' }
            },
            saved_jobs: true,
        }
    });

    if (!user) return undefined;

    // Transform to a flat shape compatible with existing components
    return {
        id: user.id,
        email: user.email,
        role: user.role as 'candidate' | 'employer' | 'super_admin' | 'admin' | 'moderator' | 'analyst' | 'support',
        name: user.name,
        firstName: user.first_name || undefined,
        lastName: user.last_name || undefined,
        onboardingCompleted: user.onboarding_completed,
        avatarUrl: user.avatar_url || undefined,
        isActive: user.is_active,
        department: user.department || undefined,
        createdAt: user.created_at.toISOString(),
        bio: user.profile?.bio || undefined,
        aboutMe: user.profile?.about_me || undefined,
        skills: user.skills.map(us => us.skill.name),
        title: user.profile?.headline || undefined,
        company: user.profile?.company_name || undefined,
        location: user.profile?.location || undefined,
        phone: user.profile?.phone || undefined,
        resumeUrl: user.profile?.resume_url,
        coverLetter: user.profile?.cover_letter,
        portfolioUrl: user.profile?.portfolio_url,
        linkedIn: user.profile?.linkedin_url,
        github: user.profile?.github_url,
        website: user.profile?.website_url,
        companyWebsite: user.profile?.company_website,
        companySize: user.profile?.company_size,
        companyIndustry: user.profile?.company_industry,
        companyLogo: user.profile?.company_logo_url,
        companyDescription: user.profile?.company_description,
        savedJobIds: user.saved_jobs.map(sj => sj.job_id),
        experience: user.experiences.map(exp => ({
            id: exp.id,
            title: exp.title,
            company: exp.company,
            location: exp.location,
            startDate: exp.start_date.toISOString(),
            endDate: exp.end_date?.toISOString(),
            current: exp.is_current,
            description: exp.description,
        })),
        education: user.education.map(edu => ({
            id: edu.id,
            institution: edu.institution,
            degree: edu.degree,
            field: edu.field || '',
            startDate: edu.start_date?.toISOString() || '',
            endDate: edu.end_date?.toISOString() || '',
            description: edu.description,
        })),
    };
}

export type CurrentUser = NonNullable<Awaited<ReturnType<typeof getCurrentUser>>>;
