"use server"

import prisma from "@/lib/db";
import bcrypt from "bcryptjs";
import { cookies } from "next/headers";
import slugify from "slugify";

export async function register(formData : FormData){
    //Permet de récupérer les données demandées à l'utilisateur lors de l'inscription
    const {email,password,passwordRepeat} = Object.fromEntries(formData)

    if(password !== passwordRepeat){
        throw new Error("Le passwords ne correspond pas")
    }

    try{

        //Vérification du mail
        const verifUser = await prisma.utilisateur.findFirst({
            where : {
                ut_mail : email.toString()
            }
        })
        if(verifUser){
            throw new Error("Utilisateur déjà inscrit")
        }


        //slugify de l'email
        const slug = slugify(email.toString().substring(0,email.toString().indexOf("@")),{lower:true,strict:true})

        //hash du mdp
        const salt = await bcrypt.genSalt(10)
        const hashedPassword = await bcrypt.hash(password.toString(),salt)

        //creation de l'utilisateur
        const result = await prisma.utilisateur.create({
            data :{           
                ut_mail : email.toString(),
                ut_mdp : hashedPassword.toString(),
                ut_slug : slug
            }
        })

        if(result){
            return {success: true}
        }
        throw new Error("Anomalie lors de la création du user")

    }catch(err){
        const error = err as Error
        throw new Error(error.message || "une erreur à été rencontrée lors de la création de l'utilisateur")
    }
}

export async function login(formData : FormData){
    const {email,password} = Object.fromEntries(formData)

    try{
            //vérification si l'utilisateur est trouvé
            const user = await prisma.utilisateur.findFirst({
                where : {
                    ut_mail : email.toString()
                }
            })
            if(!user){
                throw new Error("Invalide crédential")
            }
            //vérification du mdp
            const isPasswordValid = await bcrypt.compare(password.toString(), user.ut_mdp)
            if(!isPasswordValid){
                throw new Error("Invalide crédential")
            }

            //vérification si une session de connexion existe
            const existingSession = await prisma.session.findFirst({
                where : {
                    se_ut_id : user.ut_id
                }
            })

             //vérification si la session existe mais expiré
             // delete de l'enreg pour le recréer
            let verifDeleteSession = false
            if(existingSession && new Date() > existingSession.expireAt ){
                const deleteSession = await prisma.session.delete({
                    where : {
                        se_id : existingSession.se_id
                    }
                })
                if(deleteSession){
                    verifDeleteSession = true
                }
            }

             //vérification si une session de connexion existe et tjr actif
             // on regenere le cookie ensuite
            let verifValiditeSession = false
            if(existingSession && new Date() < existingSession.expireAt){
                verifValiditeSession = true
            }

            let sessionidCreate = ""
            if(!existingSession || verifDeleteSession){
                const createSession = await prisma.session.create({
                    data : {
                        se_ut_id : user.ut_id,
                        expireAt : new Date(Date.now() + 7*24*60*60*1000)
                    }
                })
                if(createSession){
                    sessionidCreate = createSession.se_id
                }
            }

            const cookieStore = await cookies()

            if(sessionidCreate !== ""){
                 cookieStore.set("sessionId",sessionidCreate,{
                    httpOnly : true,
                    secure: process.env.NODE_ENV ==="production",
                    path:"/",
                    maxAge: 24*60*60,
                    sameSite: "lax"
                })
            }
            if(verifValiditeSession  && existingSession?.se_id){
                cookieStore.set("sessionId",existingSession?.se_id,{
                    httpOnly : true,
                    secure: process.env.NODE_ENV ==="production",
                    path:"/",
                    maxAge: 24*60*60,
                    sameSite: "lax"
                })
            }

            return {success : true}
    }catch(err){
        const error = err as Error
        throw new Error(error.message || "une erreur à été rencontrée lors de la connexion de l'utilisateur")
    }
}    


export async function verifSession(){
    try{
        const cookie = await cookies()
        const verif = cookie.get("sessionId")
        if(verif){
            const verifExpireSession = await prisma.session.findUnique({
                where : {
                    se_id : verif.value
                }
            })
            if(verifExpireSession && new Date() > verifExpireSession.expireAt){
                await prisma.session.delete({
                    where : {
                        se_id : verifExpireSession.se_id
                    }
                })
                return {success : false}
            }else{
                cookie.set("sessionId",verif.value,{
                    httpOnly : true,
                    secure: process.env.NODE_ENV ==="production",
                    path:"/",
                    maxAge: 24*60*60,
                    sameSite: "lax"
                })
                return {success : true}
            }
        }
        return {success : false}

    }catch(err){
        const error = err as Error
        throw new Error(error.message || "une erreur à été rencontrée lors de la vérification de la session")
    }
}
