'use strict';

/**
 * Module dependencies
 */

// Public node modules.
const url = require('url');
const _ = require('lodash');
const mongoose = require('mongoose');
const Mongoose = mongoose.Mongoose;
const mongooseUtils = require('mongoose/lib/utils');

// Strapi helpers for models.
const { models: utilsModels }  = require('strapi-utils');


// Local helpers.
const utils = require('./utils/');
const relations = require('./relations');

/**
 * Mongoose hook
 */

/* eslint-disable prefer-template */
/* eslint-disable no-case-declarations */
/* eslint-disable no-const-assign */
/* eslint-disable no-unused-vars */
module.exports = function (strapi) {
  const hook = _.merge({

    /**
     * Default options
     */

    defaults: {
      defaultConnection: 'default',
      host: 'localhost',
      port: 27017,
      database: 'strapi',
      authenticationDatabase: '',
      ssl: false,
      debug: false
    },

    /**
     * Initialize the hook
     */

    initialize: cb => {
      _.forEach(_.pickBy(strapi.config.connections, {connector: 'strapi-mongoose'}), (connection, connectionName) => {
        const instance = new Mongoose();
        const { uri, host, port, username, password, database } = _.defaults(connection.settings, strapi.config.hook.settings.mongoose);
        const uriOptions = uri ? url.parse(uri, true).query : {};
        const { authenticationDatabase, ssl, debug } = _.defaults(connection.options, uriOptions, strapi.config.hook.settings.mongoose);

        // Connect to mongo database
        const connectOptions = {};
        const options = {};

        if (!_.isEmpty(username)) {
          connectOptions.user = username;

          if (!_.isEmpty(password)) {
            connectOptions.pass = password;
          }
        }

        if (!_.isEmpty(authenticationDatabase)) {
          connectOptions.authSource = authenticationDatabase;
        }

        connectOptions.ssl = ssl === true || ssl === 'true';
        connectOptions.useNewUrlParser = true;

        options.debug = debug === true || debug === 'true';

        instance.connect(uri || `mongodb://${host}:${port}/${database}`, connectOptions);

        for (let key in options) {
          instance.set(key, options[key]);
        }

        // Handle error
        instance.connection.on('error', error => {
          if (error.message.indexOf(`:${port}`)) {
            return cb('Make sure your MongoDB database is running...');
          }

          cb(error);
        });

        // Handle success
        instance.connection.on('open', () => {
          const mountModels = (models, target, plugin = false) => {
            if (!target) return;

            const loadedAttributes = _.after(_.size(models), () => {
              _.forEach(models, (definition, model) => {
                try {
                  let collection = strapi.config.hook.settings.mongoose.collections[mongooseUtils.toCollectionName(definition.globalName)];

                  // Set the default values to model settings.
                  _.defaults(definition, {
                    primaryKey: '_id'
                  });

                  // Initialize lifecycle callbacks.
                  const preLifecycle = {
                    validate: 'beforeCreate',
                    findOneAndUpdate: 'beforeUpdate',
                    findOneAndRemove: 'beforeDestroy',
                    remove: 'beforeDestroy',
                    update: 'beforeUpdate',
                    find: 'beforeFetchAll',
                    findOne: 'beforeFetch',
                    save: 'beforeSave'
                  };

                  /*
                    Override populate path for polymorphic association.

                    It allows us to make Upload.find().populate('related')
                    instead of Upload.find().populate('related.item')
                  */

                  const morphAssociations = definition.associations.filter(association => association.nature.toLowerCase().indexOf('morph') !== -1);

                  if (morphAssociations.length > 0) {
                    morphAssociations.forEach(association => {
                      Object.keys(preLifecycle)
                        .filter(key => key.indexOf('find') !== -1)
                        .forEach(key => {
                          collection.schema.pre(key,  function (next) {
                            if (this._mongooseOptions.populate && this._mongooseOptions.populate[association.alias]) {
                              if (association.nature === 'oneToManyMorph' || association.nature === 'manyToManyMorph') {
                                this._mongooseOptions.populate[association.alias].match = {
                                  [`${association.via}.${association.filter}`]: association.alias,
                                  [`${association.via}.kind`]: definition.globalId
                                };

                                // Select last related to an entity.
                                this._mongooseOptions.populate[association.alias].options = {
                                  sort: '-createdAt'
                                };
                              } else {
                                this._mongooseOptions.populate[association.alias].path = `${association.alias}.ref`;
                              }
                            }
                            next();
                          });
                        });
                    });
                  }

                  _.forEach(preLifecycle, (fn, key) => {
                    if (_.isFunction(target[model.toLowerCase()][fn])) {
                      collection.schema.pre(key, function (next) {
                        target[model.toLowerCase()][fn](this).then(next).catch(err => strapi.log.error(err));
                      });
                    }
                  });

                  const postLifecycle = {
                    validate: 'afterCreate',
                    findOneAndRemove: 'afterDestroy',
                    remove: 'afterDestroy',
                    update: 'afterUpdate',
                    find: 'afterFetchAll',
                    findOne: 'afterFetch',
                    save: 'afterSave'
                  };

                  // Mongoose doesn't allow post 'remove' event on model.
                  // See https://github.com/Automattic/mongoose/issues/3054
                  _.forEach(postLifecycle, (fn, key) => {
                    if (_.isFunction(target[model.toLowerCase()][fn])) {
                      collection.schema.post(key, function (doc, next) {
                        target[model.toLowerCase()][fn](this, doc).then(next).catch(err => strapi.log.error(err));
                      });
                    }
                  });

                  // Add virtual key to provide populate and reverse populate
                  _.forEach(_.pickBy(definition.loadedModel, model => {
                    return model.type === 'virtual';
                  }), (value, key) => {
                    collection.schema.virtual(key.replace('_v', ''), {
                      ref: value.ref,
                      localField: '_id',
                      foreignField: value.via,
                      justOne: value.justOne || false
                    });
                  });

                  collection.schema.set('timestamps', _.get(definition, 'options.timestamps') === true);
                  collection.schema.set('minimize', _.get(definition, 'options.minimize', false) === true);

                  collection.schema.options.toObject = collection.schema.options.toJSON = {
                    virtuals: true,
                    transform: function (doc, returned, opts) {
                      // Remover $numberDecimal nested property.
                      Object.keys(returned)
                        .filter(key => returned[key] instanceof mongoose.Types.Decimal128)
                        .forEach((key, index) => {
                          // Parse to float number.
                          returned[key] = parseFloat(returned[key].toString());
                        });

                      morphAssociations.forEach(association => {
                        if (Array.isArray(returned[association.alias]) && returned[association.alias].length > 0) {
                          // Reformat data by bypassing the many-to-many relationship.
                          switch (association.nature) {
                            case 'oneMorphToOne':
                              returned[association.alias] = returned[association.alias][0].ref;
                              break;
                            case 'manyMorphToMany':
                            case 'manyMorphToOne':

                              returned[association.alias] = returned[association.alias].map(obj => obj.ref);
                              break;
                            default:

                          }
                        }
                      });
                    }
                  };

                  // Instantiate model.
                  const Model = instance.model(definition.globalId, collection.schema, definition.collectionName);

                  if (!plugin) {
                    global[definition.globalName] = Model;
                  }

                  // Expose ORM functions through the `target` object.
                  target[model] = _.assign(Model, target[model]);

                  // Push attributes to be aware of model schema.
                  target[model]._attributes = definition.attributes;
                  target[model].updateRelations = relations.update;
                } catch (err) {
                  strapi.log.error('Impossible to register the `' + model + '` model.');
                  strapi.log.error(err);
                  strapi.stop();
                }
              });
            });

            // Parse every authenticated model.
            _.forEach(models, (definition, model) => {
              definition.globalName = _.upperFirst(_.camelCase(definition.globalId));

              // Make sure the model has a connection.
              // If not, use the default connection.
              if (_.isEmpty(definition.connection)) {
                definition.connection = strapi.config.currentEnvironment.database.defaultConnection;
              }

              // Make sure this connection exists.
              if (!_.has(strapi.config.connections, definition.connection)) {
                strapi.log.error('The connection `' + definition.connection + '` specified in the `' + model + '` model does not exist.');
                strapi.stop();
              }

              // Add some informations about ORM & client connection
              definition.orm = 'mongoose';
              definition.client = _.get(strapi.config.connections[definition.connection], 'client');
              definition.associations = [];

              // Register the final model for Mongoose.
              definition.loadedModel = _.cloneDeep(definition.attributes);

              // Initialize the global variable with the
              // capitalized model name.
              if (!plugin) {
                global[definition.globalName] = {};
              }

              if (_.isEmpty(definition.attributes)) {
                // Generate empty schema
                _.set(strapi.config.hook.settings.mongoose, 'collections.' + mongooseUtils.toCollectionName(definition.globalName) + '.schema', new instance.Schema({}));

                return loadedAttributes();
              }

              // Call this callback function after we are done parsing
              // all attributes for relationships-- see below.
              const done = _.after(_.size(definition.attributes), () => {
                // Generate schema without virtual populate
                const schema = new instance.Schema(_.omitBy(definition.loadedModel, model => {
                  return model.type === 'virtual';
                }));

                _.set(strapi.config.hook.settings.mongoose, 'collections.' + mongooseUtils.toCollectionName(definition.globalName) + '.schema', schema);

                loadedAttributes();
              });

              // Add every relationships to the loaded model for Bookshelf.
              // Basic attributes don't need this-- only relations.
              _.forEach(definition.attributes, (details, name) => {
                const verbose = _.get(utilsModels.getNature(details, name, undefined, model.toLowerCase()), 'verbose') || '';

                // Build associations key
                utilsModels.defineAssociations(model.toLowerCase(), definition, details, name);

                if (_.isEmpty(verbose)) {
                  definition.loadedModel[name].type = utils(instance).convertType(details.type);
                }

                switch (verbose) {
                  case 'hasOne': {
                    const ref = details.plugin ? strapi.plugins[details.plugin].models[details.model].globalId : strapi.models[details.model].globalId;

                    definition.loadedModel[name] = {
                      type: instance.Schema.Types.ObjectId,
                      ref
                    };
                    break;
                  }
                  case 'hasMany': {
                    const FK = _.find(definition.associations, {alias: name});
                    const ref = details.plugin ? strapi.plugins[details.plugin].models[details.collection].globalId : strapi.models[details.collection].globalId;

                    if (FK) {
                      definition.loadedModel[name] = {
                        type: 'virtual',
                        ref,
                        via: FK.via,
                        justOne: false
                      };

                      // Set this info to be able to see if this field is a real database's field.
                      details.isVirtual = true;
                    } else {
                      definition.loadedModel[name] = [{
                        type: instance.Schema.Types.ObjectId,
                        ref
                      }];
                    }
                    break;
                  }
                  case 'belongsTo': {
                    const FK = _.find(definition.associations, {alias: name});
                    const ref = details.plugin ? strapi.plugins[details.plugin].models[details.model].globalId : strapi.models[details.model].globalId;

                    if (FK && FK.nature !== 'oneToOne' && FK.nature !== 'manyToOne' && FK.nature !== 'oneWay' && FK.nature !== 'oneToMorph') {
                      definition.loadedModel[name] = {
                        type: 'virtual',
                        ref,
                        via: FK.via,
                        justOne: true
                      };

                      // Set this info to be able to see if this field is a real database's field.
                      details.isVirtual = true;
                    } else {
                      definition.loadedModel[name] = {
                        type: instance.Schema.Types.ObjectId,
                        ref
                      };
                    }

                    break;
                  }
                  case 'belongsToMany': {
                    const FK = _.find(definition.associations, {alias: name});
                    const ref = details.plugin ? strapi.plugins[details.plugin].models[details.collection].globalId : strapi.models[details.collection].globalId;

                    // One-side of the relationship has to be a virtual field to be bidirectional.
                    if ((FK && _.isUndefined(FK.via)) || details.dominant !== true) {
                      definition.loadedModel[name] = {
                        type: 'virtual',
                        ref,
                        via: FK.via
                      };

                      // Set this info to be able to see if this field is a real database's field.
                      details.isVirtual = true;
                    } else {
                      definition.loadedModel[name] = [{
                        type: instance.Schema.Types.ObjectId,
                        ref
                      }];
                    }
                    break;
                  }
                  case 'morphOne': {
                    const FK = _.find(definition.associations, {alias: name});
                    const ref = details.plugin ? strapi.plugins[details.plugin].models[details.model].globalId : strapi.models[details.model].globalId;

                    definition.loadedModel[name] = {
                      type: 'virtual',
                      ref,
                      via: `${FK.via}.ref`,
                      justOne: true
                    };

                    // Set this info to be able to see if this field is a real database's field.
                    details.isVirtual = true;
                    break;
                  }
                  case 'morphMany': {
                    const FK = _.find(definition.associations, {alias: name});
                    const ref = details.plugin ? strapi.plugins[details.plugin].models[details.collection].globalId : strapi.models[details.collection].globalId;

                    definition.loadedModel[name] = {
                      type: 'virtual',
                      ref,
                      via: `${FK.via}.ref`
                    };

                    // Set this info to be able to see if this field is a real database's field.
                    details.isVirtual = true;
                    break;
                  }
                  case 'belongsToMorph': {
                    definition.loadedModel[name] = {
                      kind: String,
                      [details.filter]: String,
                      ref: {
                        type: instance.Schema.Types.ObjectId,
                        refPath: `${name}.kind`
                      }
                    };
                    break;
                  }
                  case 'belongsToManyMorph': {
                    definition.loadedModel[name] = [{
                      kind: String,
                      [details.filter]: String,
                      ref: {
                        type: instance.Schema.Types.ObjectId,
                        refPath: `${name}.kind`
                      }
                    }];
                    break;
                  }
                  default:
                    break;
                }

                done();
              });
            });
          };

          // Mount `./api` models.
          mountModels(_.pickBy(strapi.models, { connection: connectionName }), strapi.models);

          // Mount `./plugins` models.
          _.forEach(strapi.plugins, (plugin, name) => {
            mountModels(_.pickBy(strapi.plugins[name].models, { connection: connectionName }), plugin.models, name);
          });

          cb();
        });
      });
    },

    getQueryParams: (value, type, key) => {
      const result = {};

      switch (type) {
        case '=':
          result.key = `where.${key}`;
          result.value = value;
          break;
        case '_ne':
          result.key = `where.${key}.$ne`;
          result.value = value;
          break;
        case '_lt':
          result.key = `where.${key}.$lt`;
          result.value = value;
          break;
        case '_gt':
          result.key = `where.${key}.$gt`;
          result.value = value;
          break;
        case '_lte':
          result.key = `where.${key}.$lte`;
          result.value = value;
          break;
        case '_gte':
          result.key = `where.${key}.$gte`;
          result.value = value;
          break;
        case '_sort':
          result.key = `sort`;
          result.value = (_.toLower(value) === 'desc') ? '-' : '';
          result.value += key;
          break;
        case '_start':
          result.key = `start`;
          result.value = parseFloat(value);
          break;
        case '_limit':
          result.key = `limit`;
          result.value = parseFloat(value);
          break;
        case '_contains':
          result.key = `where.${key}`;
          result.value = {
            $regex: value,
            $options: 'i',
          };
          break;
        case '_containss':
          result.key = `where.${key}.$regex`;
          result.value = value;
          break;
        case '_in':
          result.key = `where.${key}.$in`;
          result.value = value;
          break;
        default:
          result = undefined;
      }

      return result;
    }
  }, relations);

  return hook;
};