import { Planets, Users } from '../db/mongodb';
import type User from '../../types/User';
import type AccessToken from '../../types/AccessToken';
import { ObjectId } from 'mongodb';
import { hash } from 'argon2'
import { createInitialResources } from '../utils/resourceManager';
import type Research from '../../types/Research';

export const getAllUsers = async () => {
    const users = await Users();
    return users.find({}).toArray() as Promise<User[]>;
}

export const createUser = async (username: string, email: string, password: string) => {
    const user: User = {
        username,
        email,
        password: await hash(password),
        lastLogin: new Date(),
        createdAt: new Date(),
        updatedAt: new Date(),
        //@ts-ignore
        resources: {}
    }

    
    await (await Users()).insertOne(user);
    const newUser = await getUserByNickOrEmail(username);
    if(!newUser) return user;
    createInitialResources(newUser._id);
    return newUser;
}

export const deleteUser = async (id: ObjectId) => {
    const users = await Users();
    return users.deleteOne({ _id: id });
}

export const getUserById = async (id: ObjectId) => {
    const users = await Users();
    return users.findOne({
        _id: id
    }) as Promise<User | null>;
}

export const getUserByNickOrEmail = async (searchString: string) => {
    const users = await Users();
    return users.findOne({
        $or: [
            { username: searchString },
            { email: searchString }
        ]
    }) as Promise<User | null>;
}

export const getUserByAccessToken = async(accessToken: string | AccessToken): Promise<User | null> => {
    if(typeof accessToken === "string") {
        const userId = new ObjectId(Buffer.from(accessToken.split(".")[2], 'base64url').toString());
        return getUserById(userId);
    } else return getUserById(accessToken.user as ObjectId)
}

export const updateLastLogin = async (user: User) => {
    const users = await Users();
    return users.updateOne({ username: user.username }, { $set: { lastLogin: new Date() } });
}

export const getUserResearch = async (user: User): Promise<Array<Research>> => {
    const research: Array<Research> = [];

    if (user?.research !== undefined) {
        user?.research.forEach((res: Research) => {
            research.push(res);
        });
    }

    return research;
}

export const createOrUpgradeResearch = async (username: string, research: Research) => {
    const users = await Users();

    const result = await users.updateOne(
        { username, "research.id": research.id },
        { $set: { "research.$.level": research.level } }
    );

    if (result.modifiedCount === 0) {
        await users.updateOne({ username },
            { $push: { research } }
        );
    }
}

export const getUserWithPlanets = async (id: ObjectId): Promise<User | null> => {
    const users = await Users();
    const planets = await Planets();

    const rawUser = await users.findOne({
        _id: id
    })

    if (!rawUser) return null;

    const userPlanets = (await planets.find({
        owner: id
    }).toArray()).map(planet => {
        planet.owner = rawUser;
        return planet;
    });

    rawUser.planets = {
        partial: false,
        data: userPlanets
    }

    return rawUser as User;
}