/**
 * @file Resolvers pour tous les types de messages
 * @author akka, ofacklam
 */

import { Group, SimpleGroup, MetaGroup } from "./groups";
import { User } from './users';
import { Event } from "./messages";
import knex from '../../../db/knex_router';
import { Context } from "../typeDefs/queries";
import { ApolloError } from "apollo-server-core";

export abstract class Request {

    /**
     * @memberof GraphQL
     * @class Request
     * @summary Resolvers des requetes
     * @classdesc Une classe abstraite représentant l'interface Request du schéma.
     * Comme Apollo Server, par défaut, appelle la propriété / fonction avec le nom a résoudre, il n'y a pas besoin d'écrire les resolvers explicitement.
     * @arg {number} rid - Identifiant de la requete, supposé valide.
     * @rights dépend du type de requete
     * @abstract
     */
    constructor(rid: number) {
        this.rid = rid;
        this.m_dataLoaded = false;
    }

    /**
     * @memberof GraphQL.Request#
     * @function fetchData
     * @summary Fonction qui va chercher toutes les données sur cette requete dans la BDD, si ce n'est pas déja fait.
     * @returns {Promise(boolean)} Renvoie true si le chargement est réussi.
     * @async
     * @protected
     * @abstract
     */
    protected abstract async fetchData(): Promise<boolean>

    /**
     * Protected properties.
     * Ce sont tous les champs triviaux, ie qui peuvent etre récupérés en une seule requete a la BDD,
     * ce qui permet d'etre plus efficace.
     * La variable dataLoaded témoigne de si on est déja allés chercher les données.
     * ATTENTION. Ce ne sont PAS directement les resolvers, il FAUT donc qu'ils aient un nom DIFFÉRENT du nom des champs dans le schéma.
     */
    protected m_dataLoaded: boolean

    protected m_comment: string
    protected m_from: string
    protected m_to: string

    /**
     * Ci-dessous les resolvers a proprement parler.
     */

    /**
     * @memberof GraphQL.Request#
     * @function __resolveType
     * @summary Renvoie quel type de Request c'est
     * @return {string}
     * @rights same as request object
     */
    __resolveType(): string {
        if (this instanceof UserJoinGroup) {
            return "UserJoinGroup";
        }
        else if (this instanceof GroupJoinMetagroup) {
            return "GroupJoinMetagroup";
        }
        else if (this instanceof GroupCoauthorEvent) {
            return "GroupCoauthorEvent";
        }
        else {
            throw new ApolloError("Bad request type");
        }
    }

    /** @rights same as request object */
    rid: number;

    /**
     * @memberof GraphQL.Request#
     * @function comment
     * @summary Renvoie le commentaire associé
     * @return {Promise(string)}
     * @rights same as request object
     * @async
     */
    async comment(args, context: Context, info): Promise<string> {
        await this.fetchData();
        return this.m_comment;
    }

    /**
     * @memberof GraphQL.Request#
     * @function from
     * @summary Renvoie l'émetteur de demande
     * @return {Promise(Group | User)}
     * @rights same as request object
     * @async
     * @abstract
     */
    abstract async from(args, context: Context, info);

    /**
     * @memberof GraphQL.Request#
     * @function to
     * @summary Renvoie le destinataire de la demande
     * @return {Promise(Group)}
     * @rights same as request object
     * @async
     * @abstract
     */
    abstract async to(args, context: Context, info): Promise<Group>;
}

export class UserJoinGroup extends Request {

    /**
     * @memberof GraphQL
     * @class UserJoinGroup
     * @extends GraphQL.Request
     * @summary Resolvers des requetes UserJoinGroup
     * @classdesc Une classe représentant le type UserJoinGroup du schéma.
     * Comme Apollo Server, par défaut, appelle la propriété / fonction avec le nom a résoudre, il n'y a pas besoin d'écrire les resolvers explicitement.
     * @arg {number} rid - Identifiant de la requete, supposé valide.
     * @rights admin du groupe recipient ou le user émetteur
     */
    constructor(rid: number) {
        super(rid);
    }

    /**
     * @memberof GraphQL.UserJoinGroup#
     * @function tryCreate
     * @summary Fonction qui va essayer de créer la requete correspondante
     * @arg {number} rid - Identifiant de la requete, sans hypothese sur la validité.
     * @returns {Promise(UserJoinGroup)} - Renvoie le UserJoinGroup créé, ou null en cas d'erreur.
     * @rights admin du groupe recipient ou le user émetteur
     * @async
     * @static
     */
    static async tryCreate(rid: number): Promise<UserJoinGroup> {
        let r = new UserJoinGroup(rid);
        if(await r.fetchData()) {
            return r;
        }
        return null;
    }

    /**
     * @memberof GraphQL.UserJoinGroup#
     * @function fetchData
     * @summary Fonction qui va chercher toutes les données sur cette requete dans la BDD, si ce n'est pas déja fait.
     * @returns {Promise(boolean)} Renvoie true si le chargement est réussi.
     * @async
     * @protected
     */
    protected async fetchData(): Promise<boolean> {
        if (!this.m_dataLoaded) {
            let data = await knex.select('request_comment',
                'request_from',
                'request_to').from('requests_user_join_group').where('rid', this.rid);

            if (data.length > 0) {
                let r = data[0];

                this.m_comment = r.request_comment;
                this.m_from = r.request_from;
                this.m_to = r.request_to;

                this.m_dataLoaded = true;
                return true;
            }
            else {
                return false;
            }
        }
        return true;
    }

    /**
     * Ci-dessous les resolvers a proprement parler.
     */

    /**
     * @memberof GraphQL.UserJoinGroup#
     * @function from
     * @summary Renvoie le user émetteur
     * @return {Promise(User)}
     * @rights admin du groupe recipient ou le user émetteur
     * @async
     */
    async from(args, context: Context, info): Promise<User> {
        await this.fetchData();
        return new User(this.m_from);
    }

    /**
     * @memberof GraphQL.UserJoinGroup#
     * @function to
     * @summary Renvoie le groupe destinataire
     * @return {Promise(SimpleGroup)}
     * @rights admin du groupe recipient ou le user émetteur
     * @async
     */
    async to(args, context: Context, info): Promise<SimpleGroup> {
        await this.fetchData();
        return new SimpleGroup(this.m_to);
    }
}

export class GroupJoinMetagroup extends Request {

    /**
     * @memberof GraphQL
     * @class GroupJoinMetagroup
     * @extends GraphQL.Request
     * @summary Resolvers des requetes GroupJoinMetagroup
     * @classdesc Une classe représentant le type GroupJoinMetagroup du schéma.
     * Comme Apollo Server, par défaut, appelle la propriété / fonction avec le nom a résoudre, il n'y a pas besoin d'écrire les resolvers explicitement.
     * @arg {number} rid - Identifiant de la requete, supposé valide.
     * @rights admin du groupe émetteur ou destinataire
     */
    constructor(rid: number) {
        super(rid);
    }

    /**
     * @memberof GraphQL.GroupJoinMetagroup#
     * @function tryCreate
     * @summary Fonction qui va essayer de créer la requete correspondante
     * @arg {number} rid - Identifiant de la requete, sans hypothese sur la validité.
     * @returns {Promise(GroupJoinMetagroup)} - Renvoie le GroupJoinMetagroup créé, ou null en cas d'erreur.
     * @rights admin du groupe émetteur ou destinataire
     * @async
     * @static
     */
    static async tryCreate(rid: number): Promise<GroupJoinMetagroup> {
        let r = new GroupJoinMetagroup(rid);
        if(await r.fetchData()) {
            return r;
        }
        return null;
    }

    /**
     * @memberof GraphQL.GroupJoinMetagroup#
     * @function fetchData
     * @summary Fonction qui va chercher toutes les données sur cette requete dans la BDD, si ce n'est pas déja fait.
     * @returns {Promise(boolean)} Renvoie true si le chargement est réussi.
     * @async
     * @protected
     */
    protected async fetchData(): Promise<boolean> {
        if (!this.m_dataLoaded) {
            let data = await knex.select('request_comment',
                'request_from',
                'request_to').from('requests_group_join_metagroup').where('rid', this.rid);

            if (data.length > 0) {
                let r = data[0];

                this.m_comment = r.request_comment;
                this.m_from = r.request_from;
                this.m_to = r.request_to;

                this.m_dataLoaded = true;
                return true;
            }
            else {
                return false;
            }
        }
        return true;
    }

    /**
     * Ci-dessous les resolvers a proprement parler.
     */

    /**
     * @memberof GraphQL.GroupJoinMetagroup#
     * @function from
     * @summary Renvoie le groupe émetteur
     * @return {Promise(SimpleGroup)}
     * @rights admin du groupe émetteur ou destinataire
     * @async
     */
    async from(args, context: Context, info): Promise<SimpleGroup> {
        await this.fetchData();
        return new SimpleGroup(this.m_from);
    }

    /**
     * @memberof GraphQL.GroupJoinMetagroup#
     * @function to
     * @summary Renvoie le groupe destinataire
     * @return {Promise(MetaGroup)}
     * @rights admin du groupe émetteur ou destinataire
     * @async
     */
    async to(args, context: Context, info): Promise<MetaGroup> {
        await this.fetchData();
        return new MetaGroup(this.m_to);
    }
}

export class GroupCoauthorEvent extends Request {

    /**
     * @memberof GraphQL
     * @class GroupCoauthorEvent
     * @extends GraphQL.Request
     * @summary Resolvers des requetes GroupCoauthorEvent
     * @classdesc Une classe représentant le type GroupCoauthorEvent du schéma.
     * Comme Apollo Server, par défaut, appelle la propriété / fonction avec le nom a résoudre, il n'y a pas besoin d'écrire les resolvers explicitement.
     * @arg {number} rid - Identifiant de la requete, supposé valide.
     * @rights admin du groupe émetteur ou destinataire
     */
    constructor(rid: number) {
        super(rid);
    }

    /**
     * @memberof GraphQL.GroupCoauthorEvent#
     * @function tryCreate
     * @summary Fonction qui va essayer de créer la requete correspondante
     * @arg {number} rid - Identifiant de la requete, sans hypothese sur la validité.
     * @returns {Promise(GroupCoauthorEvent)} - Renvoie le GroupCoauthorEvent créé, ou null en cas d'erreur.
     * @rights admin du groupe émetteur ou destinataire
     * @async
     * @static
     */
    static async tryCreate(rid: number): Promise<GroupCoauthorEvent> {
        let r = new GroupCoauthorEvent(rid);
        if(await r.fetchData()) {
            return r;
        }
        return null;
    }

    /**
     * @memberof GraphQL.GroupCoauthorEvent#
     * @function fetchData
     * @summary Fonction qui va chercher toutes les données sur cette requete dans la BDD, si ce n'est pas déja fait.
     * @returns {Promise(boolean)} Renvoie true si le chargement est réussi.
     * @async
     * @protected
     */
    protected async fetchData(): Promise<boolean> {
        if (!this.m_dataLoaded) {
            let data = await knex.select('request_comment',
                'request_from',
                'request_to',
                'for_event').from('requests_group_coauthor_event').where('rid', this.rid);

            if (data.length > 0) {
                let r = data[0];

                this.m_comment = r.request_comment;
                this.m_from = r.request_from;
                this.m_to = r.request_to;
                this.m_forEvent = r.for_event;

                this.m_dataLoaded = true;
                return true;
            }
            else {
                return false;
            }
        }
        return true;
    }

    /**
     * Protected properties.
     * Ce sont tous les champs triviaux, ie qui peuvent etre récupérés en une seule requete a la BDD,
     * ce qui permet d'etre plus efficace.
     * La variable dataLoaded témoigne de si on est déja allés chercher les données.
     * ATTENTION. Ce ne sont PAS directement les resolvers, il FAUT donc qu'ils aient un nom DIFFÉRENT du nom des champs dans le schéma.
     */
    protected m_forEvent: number;

    /**
     * Ci-dessous les resolvers a proprement parler.
     */

    /**
     * @memberof GraphQL.GroupCoauthorEvent#
     * @function from
     * @summary Renvoie le groupe émetteur
     * @return {Promise(Group)}
     * @rights admin du groupe émetteur ou destinataire
     * @async
     */
    async from(args, context: Context, info): Promise<Group> {
        await this.fetchData();
        throw "Not implemented";
    }

    /**
     * @memberof GraphQL.GroupCoauthorEvent#
     * @function to
     * @summary Renvoie le groupe destinataire
     * @return {Promise(Group)}
     * @rights admin du groupe émetteur ou destinataire
     * @async
     */
    async to(args, context: Context, info): Promise<Group> {
        await this.fetchData();
        throw "Not implemented";
    }

    /**
     * @memberof GraphQL.GroupCoauthorEvent#
     * @function forEvent
     * @summary Renvoie l'evenement a co-organiser
     * @return {Promise(Event)}
     * @rights admin du groupe émetteur ou destinataire
     * @async
     */
    async forEvent(args, context: Context, info): Promise<Event> {
        await this.fetchData();
        throw "Not implemented";
        //a-t-il le droit de voir ???
        return new Event(this.m_forEvent);
    }
}