const mongoose = require('mongoose');
const options = {
    loggerLevel: 'error',
    useNewUrlParser: true,
    reconnectInterval: 2000,
    reconnectTries: 30, // Retry up to 30 times
    useCreateIndex: true
};

// Connect to DB
mongoose.connect(process.env.MONGO_URI, options);

// When successfully connected
mongoose.connection.on('connected', () => {
  console.log('MongoDB connected...');
});

// When successfully reconnected
mongoose.connection.on('reconnected', () => {
  console.log('dbevent: reconnected');
});

// If the connection throws an error
mongoose.connection.on('error', (err) => {
  console.log(`dbevent: error: ${err}`);
  console.log(`Retry mongo connect`);
  mongoose.connect(process.env.MONGO_URI, options);
});
  
// External Dependancies
const boom = require('boom');

// Get Data Models
const Provision = require('./models/Provision');
const Destroy = require('./models/Destroy');
const User = require('./models/User');
const Scenario = require('./models/Scenario');
const VmType = require('./models/VmType');

const getOid = async (oid, reply) => {
  try {
    const entity = await User.findOne({ oid: oid});
    return entity;
  } catch (err) {
    throw boom.boomify(err)
  }
}

const getScenarioByName = async (name, reply) => {
  try {
    const entity = await Scenario.findOne({ name: name});
    return entity;
  } catch (err) {
    throw boom.boomify(err)
  }
}

const get = async (model, filter, reply) => {
  try {
    const entity = await model.find(filter).sort({created: -1}).populate('user').populate('destroy');
    return entity;
  } catch (err) {
    throw boom.boomify(err)
  }
}

const getSingle = async (model, id, reply) => {
  try {
    const entity = await model.findById(id).populate('user').populate('destroy');
    return entity;
  } catch (err) {
    throw boom.boomify(err);
  }
};

const add = async (model, data, reply) => {
  try {
    const entity = new model(data)
    return entity.save();
  } catch (err) {
    throw boom.boomify(err);
  }
};

const update = async (model, id, body, reply) => {
  try {
    const { ...updateData } = body;
    updateData.updated = new Date();
    const update = await model.findByIdAndUpdate(id, updateData, { new: true }).populate('user').populate('destroy');
    return update;
  } catch (err) {
    throw boom.boomify(err)
  }
};

const del = async (model, id, reply) => {
  try {
    const entity = await model.findByIdAndRemove(id)
    return entity;
  } catch (err) {
    throw boom.boomify(err)
  }
}

function _m(model) {
  return {
    get: async (filter, reply) => {
      return get(model, filter, reply);
    },
    getSingle: async (id, reply) => {
      return getSingle(model, id, reply);
    },
    add: async (data, reply) => {
      return add(model, data, reply);
    },
    update: async (id, data, reply) => {
      return update(model, id, data, reply);
    },
    del: async (id, reply) => {
      return del(model, id, reply);
    }
  }
}

const mScenarios = _m(Scenario);
mScenarios.getScenarioByName = getScenarioByName;

module.exports = {
  provision: _m(Provision),
  destroy: _m(Destroy),
  scenario: mScenarios,
  vmtype: _m(VmType),
  user: {
    get: async (filter, reply) => {
      return get(User, filter, reply);
    },
    getOid: async (oid, reply) => {
      return getOid(oid, reply);
    },
    getSingle: async (req, reply) => {
      return getSingle(User, req, reply);
    },
    add: async (data, reply) => {
      return add(User, data, reply);
    },
    update: async (data, reply) => {
      return update(User, data, reply);
    }
  }
}


async function asyncForEach(array, callback) {
  for (let index = 0; index < array.length; index++) {
      await callback(array[index], index, array);
  }
}

async function toObjectId(model, fieldName, fieldNameTemp){
  var filter = {};
  filter[fieldName] = {$type : 2};
  var results = await model.find(filter);

  await asyncForEach(results, async function(d)  {
    console.log("doc", d);
    var newId = mongoose.Types.ObjectId(d[fieldName]); // to ObjectId
    var oldId = d[fieldName]; 
    d[fieldName] = undefined; 
    d[fieldNameTemp] = newId;
    await model.create(d);
    
    var remFilter = {};
    remFilter[fieldName] = oldId;
    await model.remove(remFilter);

    
  });
}

async function destroyStuff(){
  
  var results = await Destroy.find({provId:{$type : 2}});

  await asyncForEach(results, async function(d)  {
    console.log("doc", d);
    var destroy = d._id;
  
    await Provision.updateOne({_id: d.provId}, {destroy: destroy});

    d.provId = undefined;
    d.save();
    
  });
}

toObjectId(Provision, "userId", "user");
toObjectId(Destroy, "userId", "user");
destroyStuff();