/**
 * @file Fonctions qui gerent l'autorisation des utilisateurs
 * @author ofacklam
 * @memberof GraphQL
 */

import { Tools, GroupSet, GroupCollection } from "./tools";
import { User as UT } from '../../ldap/export/user'

/*
 * There are 6 levels of authorization
 *  none : doesn't know the group / the user exists
 *  connectedOrOnplatal : knows the group exists, can use TOL
 *  viewer : can see the group
 *  member : part of the group
 *  speaker : allowed to speak for the group
 *  admin : admin of the group
 */

export class AuthorizationModel {
    
    /**
     * @memberof GraphQL
     * @class AuthorizationModel
     * @summary Autorisation des utilisateurs.
     * @classdesc Cette classe contient les méthodes d'autorisation de l'utilisateur dans le 'context'.
     * @arg {string} uid - L'identifiant de l'utilisateur.
     */
    constructor(uid: string) {
        this.uid = uid;
    }

    /**
     * @memberof GraphQL
     * @summary Fonction qui crée une nouvelle instance de AuthorizationModel et charge les données
     * @arg {string} uid - Identifiant de l'utilisateur.
     * @returns {Promise(AuthorizationModel)} Renvoie un nouveau AuthorizationModel avec cet utilisateur
     * @async
     * @static
     */
    static async create(uid: string): Promise<AuthorizationModel> {
        let model = new AuthorizationModel(uid);
        console.log("constructing AuthorizationModel...");
        if(model.isAuthenticated()) {
            console.log("model is authenticated. fetching data...");
            await model.fetchData();
        }
        console.log("finished constructing AuthorizationModel");
        return model;
    }

    protected uid: string;
    protected viewerOf: GroupCollection;
    protected memberOf: GroupCollection;
    protected speakerOf: GroupCollection;
    protected adminOf: GroupCollection;

    static PUBLICUSER = "public_user";
    static ONPLATALUSER = "public_onplatal_user";

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function fetchData
     * @summary Fonction qui recupere toutes les données pour populer les champs a partir de l'uid.
     * @async
     */
    async fetchData(): Promise<void> {
        console.log("calling UT.peek from ldap connector (User Tool)...")
        let data = await UT.peek(this.uid);
        console.log("UT.peek returned with data:");
        //console.log(data);

        this.memberOf = await Tools.memberOf(data);
        this.speakerOf = await Tools.speakerOf(data);
        this.adminOf = await Tools.adminOf(data);
        this.viewerOf = await Tools.viewerOf(this.memberOf);
        //console.log(this.viewerOf);
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function getUid
     * @summary Fonction qui renvoit l'identifiant de l'utilisateur
     * @return {string} Renvoie l'uid de l'utilisateur du 'context'
     */
    getUid(): string {
        return this.uid;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isConnectedOrOnplatal
     * @summary Fonction qui renvoit si l'utilisateur est connecté ou on-platal
     * @return {boolean} Renvoie true si l'utilisateur est connecté ou on-platal
     */
    isConnectedOrOnplatal(): boolean {
        return (this.uid != AuthorizationModel.PUBLICUSER);
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isAuthenticated
     * @summary Fonction qui renvoit si l'utilisateur est authentifié
     * @return {boolean} Renvoie true si l'utilisateur est authentifié
     */
    isAuthenticated(): boolean {
        console.log("running model.isAuthenticated...");
        return (this.uid != AuthorizationModel.PUBLICUSER && this.uid != AuthorizationModel.ONPLATALUSER);
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isViewer
     * @summary Fonction qui renvoit si l'utilisateur est viewer du groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {boolean} Renvoie true si l'utilisateur est viewer du groupe.
     */
    isViewer(gid: string): boolean {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            let groups = this.viewerOf;
            return (groups.simpleGroups.has(gid) || groups.metaGroups.has(gid));
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function groupsViewer
     * @summary Fonction qui renvoit les groupes dont l'utilisateur est viewer.
     * @return {GroupCollection} Renvoie la collection de groupes dont l'utilisateur est viewer.
     */
    groupsViewer(): GroupCollection {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            return this.viewerOf;
        }
        return null;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isMember
     * @summary Fonction qui renvoit si l'utilisateur est membre du groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {boolean} Renvoie true si l'utilisateur est membre du groupe.
     */
    isMember(gid: string): boolean {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            let groups = this.memberOf;
            return (groups.simpleGroups.has(gid) || groups.metaGroups.has(gid));
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isMemberOr
     * @summary Fonction qui renvoit si l'utilisateur est membre d'au moins un de ces groupes.
     * @arg {GroupSet} groups - Ensemble de groupes.
     * @return {boolean} Renvoie true si l'utilisateur est membre d'un des groupes
     */
    isMemberOr(groups: GroupSet): boolean {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            let member = this.memberOf;

            for (let gid of groups) {
                if (member.simpleGroups.has(gid) || member.metaGroups.has(gid)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function groupsMember
     * @summary Fonction qui renvoit les groupes dont l'utilisateur est member.
     * @return {GroupCollection} Renvoie la collection de groupes dont l'utilisateur est member.
     */
    groupsMember(): GroupCollection {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            return this.memberOf;
        }
        return null;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isSpeaker
     * @summary Fonction qui renvoit si l'utilisateur est speaker du groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {boolean} Renvoie true si l'utilisateur est speaker du groupe.
     */
    isSpeaker(gid: string): boolean {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            let groups = this.speakerOf;
            return (groups.simpleGroups.has(gid) || groups.metaGroups.has(gid));
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function groupsSpeaker
     * @summary Fonction qui renvoit les groupes dont l'utilisateur est speaker.
     * @return {GroupCollection} Renvoie la collection de groupes dont l'utilisateur est speaker.
     */
    groupsSpeaker(): GroupCollection {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            return this.speakerOf;
        }
        return null;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isAdmin
     * @summary Fonction qui renvoit si l'utilisateur est admin du groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {boolean} Renvoie true si l'utilisateur est admin du groupe.
     */
    isAdmin(gid: string): boolean {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            let groups = this.adminOf;
            return (groups.simpleGroups.has(gid) || groups.metaGroups.has(gid));
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function groupsAdmin
     * @summary Fonction qui renvoit les groupes dont l'utilisateur est admin.
     * @return {GroupCollection} Renvoie la collection de groupes dont l'utilisateur est admin.
     */
    groupsAdmin(): GroupCollection {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            return this.adminOf;
        }
        return null;
    }

}