import * as GQL from 'graphql'
import * as db from '../models'
import * as R from 'graphql-relay'

const nodeDefinitions = R.nodeDefinitions(globalId => {
    const modelTypes = ['User', 'Message']
    const idInfo = R.fromGlobalId(globalId)
    const typeIndex = modelTypes.indexOf(idInfo.type)
    if (typeIndex !== -1) { return db[modelTypes[typeIndex]].get(idInfo.id).run() }
    return null
})

/**********************************************************************/
/*                         MODEL DEFINITIONS                          */
/**********************************************************************/
//============================== MESSAGE ================================//
const MessageType = new GQL.GraphQLObjectType({
    name: 'Message',
    isTypeOf: (obj): boolean => {
        try { new db.Message(obj).validate(); return true } catch (e) { return false }
    },
    fields: (): GQL.GraphQLFieldConfigMap => ({
        id: R.globalIdField('Message'),
        userId: { type: new GQL.GraphQLNonNull(GQL.GraphQLString) },
        createdAt: { type: GQL.GraphQLString },
        body: { type: GQL.GraphQLString },
        user: {
            type: UserType,
            resolve: async (msg, args): Promise<any> => await db.User.get(msg.userId).run()
        }
    }),

        }
    }),
});
// Object Identification
// nodeDefinitions returns the Node interface that objects can implement, and returns the node root field to include on the query type.
// To implement this, it takes a function to resolve an ID to an object, and to determine the type of a given object.
const resolver: GraphQLTypeResolver<any, any> = () => {
    return new GraphQLObjectType({
        name: "T",
        fields: {},
    });
};
const idFetcher = (id: string, context: number, info: GraphQLResolveInfo) => {
    info.fieldName = "f";
};
const nodeDef = nodeDefinitions<number>(idFetcher, resolver);
const fieldConfig: GraphQLFieldConfig<any, any> = nodeDef.nodeField;
const interfaceType: GraphQLInterfaceType = nodeDef.nodeInterface;
// toGlobalId takes a type name and an ID specific to that type name, and returns a "global ID" that is unique among all types.
toGlobalId("t", "i").toLowerCase();
// fromGlobalId takes the "global ID" created by toGlobalID, and returns the type name and ID used to create it.
const fgi = fromGlobalId("gid");
fgi.id.toLowerCase();
fgi.type.toUpperCase();
// globalIdField creates the configuration for an id field on a node.
const idFetcher2 = (object: any, context: any, info: GraphQLResolveInfo) => {
    return "";
};
const gif: GraphQLFieldConfig<any, any> = globalIdField("t", idFetcher2);
// pluralIdentifyingRootField creates a field that accepts a list of non-ID identifiers (like a username) and maps them to their corresponding objects.
const input: GraphQLInputType = GraphQLString;

  } else if (global.type === 'User') {
    return await context.db.collection('users').find({ _id: new ObjectID(global.id) }).limit(1).next();

  }
  return null;

}

export let nodeDefs: GraphQLNodeDefinitions = nodeDefinitions(
  idFetcher,
  (obj) => {
    if (obj instanceof Store) {
      return storeType;

    } else if (obj.cross) {
      return seedType;

    } else if (obj.email) {
      return userType;
    }
    return null;
  }

);

userType = new GraphQLObjectType(new UserTypeConfig().getConfig());
export let userConnection: GraphQLConnectionDefinitions = connectionDefinitions({
  name: 'user',
  nodeType: userType
});