const Dashboard = dynamic(() => import('../pages/Dashboard'), { ssr: false })

export default function Page() {
  return 
}

'use client'

import { Component } from './actions'

export default function Page(props) {


  return (
    <>
        <Component/>
    </>
  );
}

  15 | export default function Dashboard({ success }: { success?: boolean }) {
> 16 |   const [user]: [Required<User>] = useOutletContext()

function AuthenticationProvider({ children }: any) {
  const [isAuthenticated, setIsAuthenticated] =
    useRecoilState(authenticationState)
  const [user, setUser] = useRecoilState(userState)
  const { isLoading } = useUser()
  const reset = () => {
    setUser({} as User)
    setIsAuthenticated(false)
  }

  return (
    <AuthenticationContext.Provider
      value={{
        user,
        isAuthenticated,
        isLoading,
        reset,
      }}
    >
      {!isLoading && <Outlet />}
      {isLoading && <Loading />}
    </AuthenticationContext.Provider>
  )
}

export function validateAuthenticationtoken(cookie) {
    if (!cookie) {
        cookie = getAuthenticationCookie();
 
        if (!cookie) {
            throw 'Authentication cookie not present';
        }
    }
 
    try {
        const options = {
            issuer: process.env.JwtIssuer,
            expiresIn: (process.env.JwtTimeToLive + 'h'),
            algorithm: process.env.JwtAlgorithm
        };
 
        const jwtToken = jwt.verify(cookie, JWTPublicKey, options)
        return jwtToken;
    }
    catch (error) {
        console.error(`Token Validation Failure: ${error.message}`)
        return false;
    }
};
 
export async function generateAuthenticationToken(access) {
    const options = {
        issuer: process.env.JwtIssuer,
        subject: access.userid,
        expiresIn: (process.env.JwtTimeToLive + 'h'),
        algorithm: process.env.JwtAlgorithm
    };
 
    const jwtPayload = {
        access: access
    }
 
    try {
        const jwtToken = jwt.sign(jwtPayload, jwtPrivateKey, options)
        return jwtToken;
    }
    catch (error) {
        console.log(error)
        return false;
    }
};

import "server-only"
import { cache } from "react"
import { cookies } from "next/headers"
import { jwtVerify, SignJWT } from "jose"
import { env } from "./env"

const JWTToken = new TextEncoder().encode(env.JWT_TOKEN)

export const getUserByToken = cache(
    async (token: string): Promise<string | null> => {
        const jwt = await jwtVerify(token, JWTToken, { algorithms: ["HS256"] })
        const userId = jwt.payload.sub

        if (!userId) return null

        return userId
    },
)

export const createUserToken = (user: { id: string }) => {
    return new SignJWT({ hello: "world" })
        .setProtectedHeader({ alg: "HS256" })
        .setIssuedAt()
        .setNotBefore(Date.now() / 1000 - 60_000)
        .setExpirationTime("7d")
        .setSubject(user.id.toString())
        .sign(JWTToken)
}

export const addUserTokenToCookie = async (user: { id: string }) => {
    const token = await createUserToken(user)
    cookies().set("token", token, {
        expires: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
        path: "/",
        sameSite: "lax",
        httpOnly: true,
        secure: true,
    })
}

export const getCurrentUser = (async () => {
    const token = cookies().get("token")
    if (!token || !token.value) return null
    try {
        return await getUserByToken(token.value)
    } catch (e) {
        // console.log(e)
        console.log("[JWT_ERROR] Token is invalid or expired. Redirecting to login.")
        return null
    }
})

export const removeToken = () => cookies().delete("token")

      // {
      //   source: '/contact/:name/:contact_id',
      //   destination: '/',
      // },