/**
 * @file Implémentation des requêtes GraphQL.
 * @author akka vodol
*/
import { request } from 'https';
import _ from 'lodash';
import { assertBinaryExpression } from 'babel-types';
import knex from '../../db/knex_router';

import * as connectors from './connectors/connectors.js';
import { connect } from 'http2';

/** 
 * @description Résolveurs des différentes requêtes GraphQL
*/
export const resolvers = {
    Query: {

        asAdmin: async function (obj, args, context){
            if(await connectors.hasAdminRights(context.user, args.groupUID))
                return {groupUID : args.groupUID};
            else
                throw "You do not have admin rights over this group";
        },

        asMember: function (obj, args, context){
            return {groupUID : args.groupUID};
        },

        accessGroups: (obj, args, context) => {
            return {};
        },

        accessPosts: (obj, args, context) => {
            return {};
        },

        accessUsers: (obj, args, context) => {
            return {};
        },
    },

    GroupQuery : {
        allGroups: (obj, args, context) => {
            return connectors.getAllVisibleGroups(context.user);
        },
        allSimpleGroups: (obj, args, context) => {
            return connectors.getAllVisibleSimpleGroups(context.user);
        },

        group: (obj, args, context) => {
            return connectors.getGroupIfVisible(context.user, args.uid);
        },
        simpleGroup: (obj, args, context) => {
            return connectors.getSimpleGroupIfVisible(context.user, args.uid);
        },
        metaGroup: (obj, args, context) => {
            return connectors.getMetaGroupIfVisible(context.user, args.uid);
        }
    },

    MessageQuery : {
        allPosts: (obj, args, context) => {
            return knex.select().from('posts');
        },
        post: (obj, args, context) => {
            const result = knex.select().from('posts').where('id','=',args.id);
            return result.then((res) => res[0]);
        },
    },

    UserQuery: {
        user: (obj, args, context) => {
            
            return connectors.getUser(context.user,args.uid);
        },

        searchTOL: (obj, args, context) => {
            console.log(args);
            return connectors.repliquerTOLdesIds(context.user, {
                givenName: args.givenName,
                lastName: args.lastName,
                nickname: args.nickname,
                nationality: args.nationality,
                school: args.school,
                promotion: args.promotion,
                groups: args.groups,
                studies: args.studies,
                sport: args.sport,
                phone: args.phone,
                mail: args.mail,
                adress: args.adress,
                ip: args.ip
            });
        }
    },

    AdminQuery: {
        isAdmin: (obj, args, context) => {
            return true;
        },

        allRequests: (obj, args, context) => {
            console.log(obj);
            return obj;
        }
    },

    MemberQuery: {
        isMember: (obj, args, context) => {
            return true;
        },

        allMembers: async function (obj, args, context){
            let cb = await connectors.getMetaGroupMembersCallback(context.user, obj.groupUID);
            return cb(knex);
        }
    },

    AllRequests: {
        userJoinGroup : (obj, args, context) => {
            return connectors.getUserJoinGroupRequests(context.user, obj.groupUID);
        },

        groupJoinEvent : (obj, args, context) => {
            return connectors.getGroupJoinEventRequests(context.user, obj.groupUID);
        },

        yourGroupHostEvent : (obj, args, context) => {
            return connectors.getYourGroupHostEventRequests(context.user, obj.groupUID);
        },
    },

    UserJoinGroup: {
        user : (obj, args, context) => {
            return connectors.getUser(context.user, obj.useruid);
            /*return connectors.getUser(context.user, "quentin.gendre");
            if(obj.useruid === "anatole.romon"){
                return connectors.getUser(context.user, "anatole.romon").then(res => {
                    return connectors.getUser(context.user, "quentin.gendre");
                });
            }else{
                return new Promise( (resolve, reject) => {
                    resolve({givenName : "patrick"});
                });
            }*/
        }
    },

    GroupJoinEvent : {
        event: (obj, args, context) => {
            return connectors.getEvent(context.user, obj.eventuid);
        },
        groupWantingToJoin: (obj, args, context) => {
            return connectors.getGroup(context.user, obj.senderuid);
        }
    },

    YourGroupHostEvent : {
        event: (obj, args, context) => {
            return connectors.getEvent(context.user, obj.eventuid);
        },
        sender: (obj, args, context) => {
            return connectors.getGroup(context.user, obj.senderuid);
        }
    },

    User : {
        groups : (obj, args, context) => {
            let result = Promise.all(obj.groups.map((grid) => {
                return connectors.getSimpleGroup(context.user,grid);
            }));

            return result.then(groups => {
                return _.filter(groups,(o) => !_.isUndefined(o));
            });
        },

    },

    Mutation: {
        asAdmin: (obj, args, context) => {
            return connectors.hasAdminRights(context.user, args.groupUID).then(res => {
                if(res)
                    return {groupUID : args.groupUID};
                else
                    throw "You do not have admin rights over this group";
            });
        },

        asSpeaker: (obj, args, context) => {
            return connectors.hasAdminRights(context.user, args.groupUID).then(res => {
                if(res)
                    return {groupUID : args.groupUID};
                else
                    throw "You do not have publishing rights in this group";
            });
        },

        asMember: (obj, args, context) => {
            return connectors.isMember(context.user, args.groupUID).then(res => {
                if(res)
                    return {groupUID : args.groupUID};
                else
                    throw "You are  not a member of this group";
            });
        },
        asViewer: (obj, args, context) => {
            return connectors.getGroupIfVisible(context.user, args.groupUID).then(res => {
                if(res)
                    return {groupUID : args.groupUID};
                else
                    throw "You are  not a member of this group";
            });
        }
    },

    AdminMutation: {
        isAdmin: (obj, args, context) => {
            return true;
        
        },
        createSubgroup: (obj, args, context) => {
            args.parentuid = obj.groupUID;
            return connectors.createSubgroup(context.user, args);
        },

        editGroup: (obj, args, context) => {
            return null;
        }
    },

    ViewerMutation: {
        requestJoin: (obj, args, context) => {
            console.log(obj);
            return null;
        }
    },

    Post: {
        authors: (obj, args, context) => {
            return knex.select().from('groups').whereIn('uid',obj.authors);
        }
    },

    Group: {
        __resolveType: (obj) => {
            
            switch(obj.type){
            case "simple":
                return "SimpleGroup";
            case "meta":
                return "MetaGroup";
            default:
                return undefined;
            }
        }
    },

    SimpleGroup: {
        members: (obj, args, context) => {
            return connectors.listerMembres(context.user,obj.uid);
        }
    },

    MetaGroup: {
        members: (obj, args, context) => {
        }
    }
};