const mongoose = require('mongoose').set('debug', false);
const Schema = mongoose.Schema;

const tools = require('../tools/general');

const shared_consts = require('../tools/shared_nodejs');

mongoose.Promise = global.Promise;
mongoose.level = 'F';

// Resolving error Unknown modifier: $pushAll
mongoose.plugin(schema => {
  schema.options.usePushEach = true;
});

const MyGroupSchema = new Schema({
  _id: {
    type: Number,
  },
  idapp: {
    type: String,
  },
  groupname: {
    type: String,
  },
  title: {
    type: String,
  },
  descr: {
    type: String,
  },
  idCatGrp: {
    type: Number,
  },
  userId: {
    type: String,
  },
  photos: [
    {
      imagefile: {
        type: String,
      },
      alt: {
        type: String,
      },
      description: {
        type: String,
      },
    }],
  idCity: [
    {
      type: Number,
    }],
  website: {
    type: String,
  },
  link_telegram: {
    type: String,
  },
  note: {
    type: String,
    default: '',
  },
  //**ADDFIELD_MYGROUPS
  visibility: [
    {
      type: Number,
    },
  ],
  pwd_cryp: {
    type: String,
  },
  createdBy: {
    type: String,
  },
  admins: [
    {
      username: {type: String},
      date: {type: Date},
    },
  ],
  blocked: {
    type: Boolean,
  },
  username_who_block: {
    type: String,
  },
  date_created: {
    type: Date,
  },
  date_updated: {
    type: Date,
  },
  date_blocked: {
    type: Date,
  },
  req_users: [
    {
      _id: false,
      username: {type: String},
      date: {type: Date},
    }],  // username
  refused_users: [
    {
      _id: false,
      username: {type: String},
      date: {type: Date},
    }],  // username
  deleted: {
    type: Boolean,
    default: false,
  },
});

MyGroupSchema.statics.getFieldsForSearch = function() {
  return [{field: 'descr', type: tools.FieldType.string}];
};

MyGroupSchema.statics.executeQueryTable = function(idapp, params, user) {
  params.fieldsearch = this.getFieldsForSearch();

  const {User} = require('./user');

  if (params.options) {
    if (tools.isBitActive(params.options, shared_consts.OPTIONS_SEARCH_USER_ONLY_FULL_WORDS)) {
      params.fieldsearch = User.getFieldsForSearchUserFriend();
    } else if (tools.isBitActive(params.options, shared_consts.OPTIONS_SEARCH_USER_ALL_WORDS)) {
      params.fieldsearch = User.getFieldsForSearchUserFriend_AllWords();
    }
  }

  return tools.executeQueryTable(this, idapp, params, user);
};

MyGroupSchema.pre('save', async function(next) {
  if (this.isNew) {
    const myrec = await MyGroup.findOne().limit(1).sort({_id: -1});
    if (!!myrec) {
      if (myrec._doc._id === 0)
        this._id = 1;
      else
        this._id = myrec._doc._id + 1;

    } else {
      this._id = 1;
    }

    this.date_created = new Date();
  }

  next();
});

MyGroupSchema.statics.findAllIdApp = async function(idapp) {
  const myfind = {idapp};

  return await MyGroup.find(myfind);
};

MyGroupSchema.statics.findAllGroups = async function(idapp) {

  const whatToShow = this.getWhatToShow(idapp, '');

  return await MyGroup.find({
    idapp,
    $or: [
      {deleted: {$exists: false}},
      {deleted: {$exists: true, $eq: false}}],
  }, whatToShow);
};

// Rimuovo la Richiesta del Gruppo
MyGroupSchema.statics.removeReqGroup = async function(idapp, username, groupnameDest) {

  return MyGroup.updateOne({idapp, groupname: groupnameDest},
      {$pull: {req_users: {username: {$in: [username]}}}});
};

// Aggiungi agli utenti Rifiutati del Gruppo
MyGroupSchema.statics.refuseReqGroup = async function(idapp, username, groupnameDest) {

  return MyGroup.updateOne({idapp, groupname: groupnameDest},
      {
        $push:
            {
              refused_users: {
                username,
                date: new Date(),
              },
            },
      });

};

// Aggiungi agli Admin del Gruppo
MyGroupSchema.statics.addToAdminOfMyGroup = async function(idapp, username, groupnameDest) {

  return MyGroup.updateOne({idapp, groupname: groupnameDest},
      {
        $push:
            {
              admins: {
                username,
                date: new Date(),
              },
            },
      });

};

// Rimuovi dagli Admin del Gruppo
MyGroupSchema.statics.removeAdminOfMyGroup = async function(idapp, username, groupnameDest) {

  return MyGroup.updateOne({idapp, groupname: groupnameDest},
      {$pull: {admins: {username: {$in: [username]}}}});
};

MyGroupSchema.statics.getWhatToShow = function(idapp, username) {
  // FOR ME, PERMIT ALL
  return {
    groupname: 1,
    title: 1,
    descr: 1,
    visibility: 1,
    idCatGrp: 1,
    userId: 1,
    photos: 1,
    idCity: 1,
    website: 1,
    //**ADDFIELD_MYGROUPS
    link_telegram: 1,
    note: 1,
    admins: 1,
    blocked: 1,
    req_users: 1,
    refused_users: 1,
    createdBy: 1,
    date_created: 1,
    date_updated: 1,
  };

};

MyGroupSchema.statics.getWhatToShow_Unknown = function(idapp, username) {
  return {
    groupname: 1,
    title: 1,
    descr: 1,
    photos: 1,
    visibility: 1,
    idCatGrp: 1,
    idCity: 1,
    note: 1,
    date_created: 1,
    date_updated: 1,
  };
};

MyGroupSchema.statics.getArrUsernameFromFieldByGroupname = async function(
    idapp, groupname, field) {

  const {User} = require('../models/user');

  const myobj = {};
  myobj[field + '.' + subfield] = 1;

  let arrrec = await User.findOne({
    idapp,
    groupname,
    $or: [{deleted: {$exists: false}}, {deleted: {$exists: true, $eq: false}}],
  }, myobj).then((ris) => ris ? ris._doc[field] : []);

  if (arrrec.length > 0) {
    return arrrec.map(m => m.username);
  }
  return [];

};

MyGroupSchema.statics.getInfoGroupByGroupname = async function(idapp, groupname) {

  const whatToShow = this.getWhatToShow(idapp, groupname);

  const rec = await MyGroup.findOne({
    idapp,
    groupname,
  }, whatToShow).lean();

  return rec;

};

MyGroupSchema.statics.deleteGroup = async function(idapp, usernameOrig, groupname) {
  console.log('Gruppo ' + groupname + ' rimosso da ' + usernameOrig);
  return MyGroup.findOneAndRemove({idapp, groupname});
};

MyGroupSchema.statics.getGroupsByUsername = async function(idapp, username, req) {

  try {
    const {User} = require('../models/user');

    const whatToShow = this.getWhatToShow(idapp, username);
    const whatToShow_Unknown = this.getWhatToShow_Unknown(idapp, username);
    const arrUsernameGroups = await User.getUsernameGroupsByUsername(idapp,
        username);
    // const arrUsernameReqGroups = await MyGroup.getUsernameReqGroupsByGroupname(idapp, username);

    let listUsersGroup = await User.find({
      idapp,
      username: {$in: arrUsernameGroups},
      $or: [
        {deleted: {$exists: false}},
        {deleted: {$exists: true, $eq: false}}],
    }, whatToShow);

    let listgroups = await MyGroup.find({
      idapp,
      $or: [
        {deleted: {$exists: false}},
        {deleted: {$exists: true, $eq: false}}],
    }, whatToShow_Unknown);

    /*let listRequestUsersGroup = await User.find({
      idapp,
      username: {$in: arrUsernameReqGroups},
      $or: [
        {deleted: {$exists: false}},
        {deleted: {$exists: true, $eq: false}}],
    }, whatToShow_Unknown);

     */

    let listSentRequestGroups = await MyGroup.find({
      idapp,
      'req_users': {
        $elemMatch: {username: {$eq: username}},
      },
      $or: [
        {deleted: {$exists: false}},
        {deleted: {$exists: true, $eq: false}}],
    }, whatToShow_Unknown);

    let listRefusedGroups = await MyGroup.find({
      idapp,
      'refused_users': {
        $elemMatch: {username: {$eq: username}},
      },
      $or: [
        {deleted: {$exists: false}},
        {deleted: {$exists: true, $eq: false}}],
    }, whatToShow_Unknown);

    return {
      listUsersGroup,
      listgroups,
      listSentRequestGroups,
      listRefusedGroups,
      mygroups: req.user.profile.mygroups,
    };

  } catch (e) {
    console.log('Error', e);
  }

  return {
    listUsersGroup: [],
    listRequestUsersGroup: [],
    listTrusted: [],
    listSentRequestGroups: [],
    listRefusedGroups: [],

  };
};

MyGroupSchema.statics.extractCitiesName = async function(idapp, id) {

  try {
    let aggr1 = [
      {
        $match: {idapp, _id: id},
      },
      {
        $lookup: {
          from: 'cities',
          localField: 'idCity',
          foreignField: '_id',
          as: 'mycities',
        },
      },
      {
        '$replaceRoot': {
          'newRoot': {
            '$mergeObjects': [
              {
                '$arrayElemAt': [
                  '$mycities',
                  0,
                ],
              },
              '$$ROOT',
            ],
          },
        },
      },
      {
        $project: {
          "mycities.comune": 1,
          "mycities.prov": 1
        },
      },
    ];

    ris = await this.aggregate(aggr1);

    return ris;
  }catch (e) {
    console.error('e', e);
  }

};


const MyGroup = mongoose.model('MyGroup', MyGroupSchema);

module.exports = {MyGroup};