export async function POST(request) {
    const data = await request.formData();
    let samlResponse = data.get('SAMLResponse'); //Get Saml Response from form data

    //Decode Saml response to readable stream
    const samlXML = base64DecodeToString(samlResponse);
    const validSAMLSignature = validateSAMLSignature(samlXML, samlPublicKey)


    //Calculating users access based on groups
    let access, authToken;
    try {
        access = await calculateUserAccess(user.userID, user.Groups)
        access = {
            roles: access.roles,
            views: access.views,
            homePage: access.homePage,
            userid: user.userID,
            firstName: user.FirstName,
            lastName: user.LastName,
            snowSupportGroup: {}
        }
        if (access.roles.some(role => role !== 'enduser')) {
            const snowDetails = await getServiceNowUserDetails(user.userID);
            access.snowSupportGroup = snowDetails;
        }

        authToken = await generateJWTToken({ access: access })
    }
    catch (error) {
        await logAuthentication(user.userID, 'Failed-10')
        return Response.redirect(`${process.env.LocalURL}/login/failed?reason=Error while reading authentication request&code=10`);
    }

    //Providing relevant cookies to browser
    try {
        cookies().set('bciamwp-auth', authToken, {
            httpOnly: true,
            path: "/",
            maxAge: 60 * process.env.JwtTimeToLive * 60,
            sameSite: 'strict',
            secure: true
        })

        cookies().set('bciamwp-nav', JSON.stringify({ access: access }), {
            httpOnly: false,
            path: "/",
            maxAge: 60 * process.env.JwtTimeToLive * 60,
            sameSite: 'strict',
            secure: true
        });
        await logAuthentication(user.userID, 'Success')
    }
    catch (error) {
        await logAuthentication(user.userID, 'Failed-11')
        return Response.redirect(`${process.env.LocalURL}/login/failed?reason=Error while reading authentication request&code=11`);
    }

    return Response.redirect(`${process.env.HttpsURL}/login/postlogin`);
}

        cookies().set('bciamwp-auth', authToken, {
            httpOnly: true,
            path: "/",
            maxAge: 60 * process.env.JwtTimeToLive * 60,
            sameSite: 'strict',
            secure: true
        })

    if (mw_IsNoAuthRoute(requestedPath) == true) {
        return NextResponse.next();
    }

export const config = {
    matcher: '/((?!api|_next|static|public|favicon.ico).*)'
}

import { cookies } from 'next/headers'

redirect('/dashboard', 'push')

import { cookies } from 'next/headers'

export async function middleware(request, res) {
    const cookieStore = cookies();

    const authenticationCookie = cookieStore.get(process.env.AuthCookieName);
    const navCookie = cookieStore.get(process.env.NavCookieName);
}

JSON.parse(navCookie.value)

export async function validateJWTToken(token) {
    try {
        if (!token) {
            token = getAuthenticationCookie();

            if (!token) {
                throw 'Authentication cookie not present';
            }
        }
        const publicKey = await importSPKI(jwtPublicKey, 'RS256');

        //Verify the token
        const { payload, protectedHeader } = await jwtVerify(token, publicKey);

        //Check additional claims
        const { alg, type, } = protectedHeader;

        if (alg !== 'RS256' || type !== 'JWT' || payload.exp < Date.now() / 1000) {
            throw new Error('Invalid token claims');
        }

        return payload;
    }
    catch (error) {
        return false;
    }
}