import * as alt from 'alt-server';
import * as yup from 'yup';
import bcrypt from 'bcryptjs';
const { genSalt, hash } = bcrypt;

import { ServerCallback } from '../helpers/Callback';

import { Positions } from '../config/Positions';

// DTO
import { UserEntity } from '../entities/User';
import { BanEntity } from '../entities/Ban';
import { EVENTS } from '../../shared/enums/Events';
import { setLocalMeta } from '../helpers/Player/Meta';
import { randomPositionAround } from '../../shared/utility/Vector';
import { ADMIN_PERMISSIONS } from '../../shared/enums/Admin';

const AuthLoginSchema = yup.object().shape({
    username: yup.string().required().min(4).max(16),
    password: yup.string().required().min(6).max(32),
});

const AuthRegistrationSchema = yup.object().shape({
    username: yup.string().required().min(4).max(16),
    password: yup.string().required().min(6).max(32),
});

interface LoginCredentials {
    username: string;
    password: string;
}

interface RegisterCredentials {
    username: string;
    password: string;
    email: string;
}

export class Auth {
    constructor() {
        new ServerCallback(EVENTS.AUTH_LOGIN, this.onLogin, AuthLoginSchema);
        new ServerCallback(EVENTS.AUTH_REGISTER, this.onRegister, AuthRegistrationSchema);
    }

    private async onLogin(player: alt.Player, done, { username, password }: LoginCredentials) {
        const User = await UserEntity.findOne({ where: { username } });

        if (!User) {
            done({
                success: false,
                error: 'user_not_found',
            });
            return;
        }

        const hashedPassword = await hash(password, User.salt);

        if (User.password != hashedPassword) {
            done({ success: false, error: 'incorrect_password' });
            return;
        }

        if (User.socialId != player.socialID) {
            done({ success: false, error: 'socialid_mismatch' });
            return;
        }

        const Ban = await BanEntity.findOne({ where: { username, socialId: player.socialID } });

        if (Ban) {
            player.kick(
                `You have been banned by ${Ban.admin}!\nReason: ${Ban.reason}\nBan date:${Ban.ban_date}\nExpiration date: ${Ban.expire_date}`
            );

            return;
        }

        player.setMeta('logged', true);
        player.setSyncedMeta('logged', true);

        setLocalMeta(player, 'inQueue', false);

        player.setMeta('admin', ADMIN_PERMISSIONS[User.admin]);
        player.setSyncedMeta('admin', ADMIN_PERMISSIONS[User.admin]);

        setLocalMeta(player, 'stats', User.stats);
        setLocalMeta(player, 'skins', User.skins);
        setLocalMeta(player, 'vehicles', User.vehicles);
        setLocalMeta(player, 'weapons', User.weapons);

        const { x, y, z } = randomPositionAround(Positions.LOBBY_POSITION, 10);

        const lobbySkin = Object.keys(User.skins.runner).find((x) => User.skins.runner[x] === true);

        player.model = lobbySkin;
        player.spawn(x, y, z, 0);
        player.maxHealth = 200;

        done({ success: true });
    }

    private async onRegister(player: alt.Player, done, { username, password, email }: RegisterCredentials) {
        const HasUser = await UserEntity.findOne({ where: { username, socialId: player.socialID, email } });

        if (HasUser) {
            if (HasUser.username == username) done({ success: false, error: 'username_already_taken' });
            if (HasUser.email == email) done({ success: false, error: 'email_already_associated_with_account' });
            if (HasUser.socialId == player.socialID)
                done({ success: false, error: 'socialid_already_associated_with_account' });

            return;
        }

        const salt = await genSalt(6),
            hashedPassword = await hash(password, salt);

        UserEntity.insert({
            username,
            password: hashedPassword,
            salt,
            socialId: player.socialID,
            email,
        })
            .then((result) => done({ success: true }))
            .catch((error) => {
                console.log(error);
                done({ success: false, error: 'idk' });
            });
    }
}

new Auth();