import prisma from '@/lib/prisma';

export class UserService {
    static async getProfile(userId: string) {
        const user = await prisma.user.findUnique({
            where: { id: userId },
            include: {
                profile: true,
                skills: { include: { skill: true } },
            }
        });

        if (!user) return undefined;

        return {
            id: user.id,
            email: user.email,
            name: user.name,
            firstName: user.first_name,
            lastName: user.last_name,
            role: user.role as 'candidate' | 'employer' | 'admin',
            bio: user.profile?.bio,
            skills: user.skills.map(us => us.skill.name),
            title: user.profile?.headline,
            company: user.profile?.company_name,
            savedJobIds: [] as string[], // Loaded separately if needed
        };
    }

    static async updateProfile(userId: string, data: {
        name?: string;
        title?: string;
        bio?: string;
        company?: string;
        skills?: string[];
    }) {
        if (data.name) {
            await prisma.user.update({
                where: { id: userId },
                data: { name: data.name }
            });
        }

        await prisma.profile.upsert({
            where: { user_id: userId },
            update: {
                headline: data.title,
                bio: data.bio,
                company_name: data.company,
            },
            create: {
                user_id: userId,
                headline: data.title,
                bio: data.bio,
                company_name: data.company,
            }
        });

        if (data.skills) {
            await prisma.userSkill.deleteMany({ where: { user_id: userId } });
            for (const skillName of data.skills) {
                const skill = await prisma.skill.upsert({
                    where: { name: skillName.trim() },
                    update: {},
                    create: { name: skillName.trim() },
                });
                await prisma.userSkill.create({
                    data: { user_id: userId, skill_id: skill.id }
                });
            }
        }

        return UserService.getProfile(userId);
    }

    static async toggleSavedJob(userId: string, jobId: string) {
        const existing = await prisma.savedJob.findUnique({
            where: {
                user_id_job_id: { user_id: userId, job_id: jobId }
            }
        });

        if (existing) {
            await prisma.savedJob.delete({
                where: {
                    user_id_job_id: { user_id: userId, job_id: jobId }
                }
            });
        } else {
            await prisma.savedJob.create({
                data: { user_id: userId, job_id: jobId }
            });
        }
        return true;
    }

    static async getSavedJobs(userId: string) {
        const savedJobs = await prisma.savedJob.findMany({
            where: { user_id: userId },
            take: 200,
            include: {
                job: {
                    include: {
                        skills: { include: { skill: true } }
                    }
                }
            }
        });

        return savedJobs.map(sj => ({
            id: sj.job.id,
            title: sj.job.title,
            company: sj.job.company,
            location: [sj.job.city, sj.job.state, sj.job.country].filter(Boolean).join(", ") || sj.job.work_location_type || "Remote",
            type: sj.job.type,
            salaryMin: sj.job.salary_min || undefined,
            salaryMax: sj.job.salary_max || undefined,
            postedAt: sj.job.posted_at.toISOString(),
            description: sj.job.description,
            skills: sj.job.skills.map(js => js.skill.name),
            applicants: sj.job.applicant_count,
            featured: sj.job.is_featured,
            employerId: sj.job.employer_id,
            status: sj.job.status as 'draft' | 'published' | 'expired' | 'archived',
        }));
    }
}
