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

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

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

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

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

const CircuitSchema = new Schema({
  idapp: {
    type: String,
  },
  Num: {
    type: Number,
    unique: true,
  },
  groupnameId: {
    type: String,
  },
  name: {
    type: String,
    unique: true,
  },
  subname: {
    type: String,
  },
  longdescr: {
    type: String,
  },
  regulation: {
    type: String,
  },
  systemUserDescr: {
    type: String,
  },
  systemUserId: {
    type: String,
  },
  founderUserId: {
    type: String,
  },
  totCircolante: {
    type: Number,
  },
  totTransato: {
    type: Number,
  },
  nome_valuta: {
    type: String,
    maxlength: 20,
  },
  symbol: {
    type: String,
    maxlength: 3,
  },
  abbrev: {
    type: String,
    maxlength: 3,
  },
  compara_valuta: {
    type: Number,
    default: 1,
  },
  compara_euro: {
    type: Number,
    default: 1,
  },
  valuta_per_euro: {
    type: Number,
    default: 1,
  },
  fido_scoperto_default: {
    type: Number,
  },
  data_costituz: {
    type: Date,
  },
  deperimento: {
    type: Boolean,
    default: true,
  },
  freq_deper: {   // H, D, W, M, Y
    type: String,
  },
  minuto_deper: {
    type: Number,
  },
  ora_deper: {
    type: Number,
  },
  giorno_deper: {
    type: Number,
  },
  mese_deper: {
    type: Number,
  },
  ultimo_deper: {
    type: Date,
  },
  durata_deper: {
    type: Number,
  },
  // -------------
  createdBy: {
    type: String,
  },
  date_created: {
    type: Date,
  },
  date_updated: {
    type: Date,
  },
  admins: [
    {
      username: {type: String},
      date: {type: Date},
    },
  ],
  img_logo: {
    type: String,
  },
  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,
  },
});

CircuitSchema.statics.findAllIdApp = async function(idapp) {
  const Circuit = this;

  const myfind = {idapp};

  return await Circuit.find(myfind, (err, arrrec) => {
    return arrrec;
  });
};

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

    } else {
      this.Num = 1;
    }
  }

  next();
});

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

CircuitSchema.statics.executeQueryTable = function(idapp, params) {
  params.fieldsearch = this.getFieldsForSearch();
  return tools.executeQueryTable(this, 0, params);
};

CircuitSchema.statics.getWhatToShow = function(idapp, username) {
  // FOR ME, PERMIT ALL
  return {
    Num: 1,
    groupnameId: 1,
    name: 1,
    subname: 1,
    longdescr: 1,
    regulation: 1,
    systemUserId: 1,
    founderUserId: 1,
    nome_valuta: 1,
    symbol: 1,
    abbrev: 1,
    data_costituz: 1,
    img_logo: 1,
  };

};

CircuitSchema.statics.getWhatToShow_Unknown = function(idapp, username) {
  return {
    Num: 1,
    groupnameId: 1,
    name: 1,
    subname: 1,
    longdescr: 1,
    regulation: 1,
    systemUserId: 1,
    founderUserId: 1,
    nome_valuta: 1,
    symbol: 1,
    abbrev: 1,
    data_costituz: 1,
    img_logo: 1,
  };
};

CircuitSchema.statics.getCircuitsByUsername = async function(idapp, username, req) {

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

    const whatToShow = this.getWhatToShow(idapp, username);
    const whatToShow_Unknown = this.getWhatToShow_Unknown(idapp, username);
    // const arrUsernameCircuits = await User.getUsernameCircuitsByUsername(idapp,
    //     username);
    // const arrUsernameReqCircuits = await MyCircuit.getUsernameReqCircuitsByCircuitname(idapp, username);

    let listUserAccounts = await Account.getAccountsByUsername(idapp, username);

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

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

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

    return {
      listUserAccounts,
      listcircuits,
      listSentRequestCircuits,
      listRefusedCircuits,
    };

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

  return {
    listUsersCircuit: [],
    listRequestUsersCircuit: [],
    listTrusted: [],
    listSentRequestCircuits: [],
    listRefusedCircuits: [],

  };
};

const Circuit = mongoose.model('Circuit', CircuitSchema);

module.exports = {Circuit};