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,
  },
  admins: [
    {
      username: {type: String},
      date: {type: Date},
    },
  ],
  blocked: {
    type: Boolean,
  },
  username_who_block: {
    type: String,
  },
  date_created: {
    type: Date,
    default: Date.now,
  },
  date_blocked: {
    type: Date,
  },
  req_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]}}}});
};

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,
  };

}

MyGroupSchema.statics.getWhatToShow_Unknown = function (idapp, username) {
  return {
    groupname: 1,
    title: 1,
    descr: 1,
    photos: 1,
    visibility: 1,
    idCatGrp: 1,
    idCity: 1,
    note: 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.getUsernameReqGroupsByGroupname = async function(
    idapp, groupname) {

  return this.getArrUsernameFromFieldByGroupname(idapp, groupname, 'req_users');

};

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

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

  return MyGroup.findOne({
    idapp,
    groupname,
  }, whatToShow).then((rec) => !!rec ? rec._doc : null);

};

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);

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

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

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

  };
};

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

module.exports = {MyGroup};
