import { createClerkClient } from "@clerk/backend";
import { ENV } from "../../config/env"
import { users } from "../../db/schema";
import { db } from "../../db";
import { eq } from "drizzle-orm";

// @ts-ignore
import jwt from "jsonwebtoken";

import { checkUserInDB, createUser, storeRefreshToken } from "../../helper/auth/auth.helper";
import { verifyAuth } from "../../middlewares/auth.middlewares";

// Initialize Clerk with your API key
const clerk = createClerkClient({ secretKey: ENV.CLERK_SECRET_KEY });

export const getUserData = async (userId: string) => {
    try {
        const [user, checkInDB] = await Promise.all([
            clerk.users.getUser(userId),
            checkUserInDB(userId)
        ]);

        if (user && !checkInDB.found) {

            // Validate and transform user data
            const userDBData = {
                id: user.id,
                email: user.emailAddresses[0].emailAddress, // Assuming the first email address
                firstName: user.firstName || "N/A", // Provide a default value if needed
                lastName: user.lastName || "N/A",
                image: user.imageUrl,
            };

            const userData = await createUser(userDBData);

            return { status: 200, message: "User retrieved successfully", data: userData };
        }
        if (user && checkInDB.found) {
            return { status: 200, message: "User retrieved successfully", data: checkInDB };
        }
        if (!user) {
            return { status: 404, message: "User not found" };
        }
    } catch (error: any) {
        console.error("Error in getUserData:", error.message || error.toString());
        return { status: 500, message: `An error occurred while getting the user` };
    }
};

export const updateUser = async (id: string, body: {
    paid_status: string,
    package_expire_date: string,
}) => {
    try {
        const updateUserData = await db.update(users).set({ paid_status: body?.paid_status, expires_in: body?.package_expire_date }).where(eq(users.id, id)).returning({ updatedId: users.id });

        return { status: 200, message: "User updated successfully", updateUserData };

    } catch (error: any) {
        console.error("Error in updateUser:", error.message || error.toString());
        return { status: 500, message: `An error occurred while updating the user` };
    }
}

export const generateToken = async (context: any) => {
    try {
        const userId = context?.params?.userId;
        const access_cookie = context?.cookie?.access_token?.value;
        const refresh_cookie = context?.cookie?.refresh_token?.value;

        if (access_cookie !== undefined || refresh_cookie !== undefined) {
            const verify = await verifyAuth(context?.cookie);
            return verify;
        }
        else if (access_cookie === undefined && refresh_cookie === undefined && userId !== undefined) {
            const user = await checkUserInDB(userId);
            if (user?.found === true) {

                // generate access token
                const accessToken = jwt.sign({ userId }, ENV.JWT_ACCESS_TOKEN_SECRET, { expiresIn: '3h' });

                // generate refresh token
                const refreshToken = jwt.sign({ userId }, ENV.JWT_REFRESH_TOKEN_SECRET, { expiresIn: '7d' });

                // store refresh token in db
                const storeRToken = await storeRefreshToken(userId, refreshToken);

                if (storeRToken.status === 200) {
                    context.cookie.access_token.set({
                        value: accessToken,
                        httpOnly: true,
                        secure: true, // Set to true in production
                        sameSite: 'none', // Adjust based on your needs
                        path: "/",
                        maxAge: 3 * 60 * 60, // 3 hours in seconds
                    });

                    context.cookie.refresh_token.set({
                        value: refreshToken,
                        httpOnly: true,
                        secure: true, // Set to true in production
                        sameSite: 'none', // Adjust based on your needs
                        path: "/",
                        maxAge: 7 * 24 * 60 * 60, // 7 days in seconds
                    });

                    return { status: 201, message: "Token generated successfully", token: accessToken, user: user.user };
                }
                return { status: 500, message: "An error occurred while storing the refresh token" };
            }
            else {
                return { status: 404, message: "User not found" };
            }
        }
        else {
            return { status: 404, message: "Unauthorized!!!" };
        }
    } catch (error: any) {
        console.error("Error in generateToken:", error.message || error.toString());
        return { status: 500, message: `An error occurred while generating the token` };
    }
}