const moment = require('moment');
const Validator = require('validatorjs');
const Helper = require('../library/LibHelper');
const GpsTracksModels = require('../models/GpsTracksModels');
const response = require('../config/response');
const LibSchedulerReverseGeocode = require('../library/LibSchedulerReverseGeocode');
const LibQueueBlastOrder = require('../library/LibQueueBlastOrder');
const LibSchedulerDrvUpLoc = require('../library/LibSchedulerDrvUpLoc');
const LibSchedulerDrvUpPhoto = require('../library/LibSchedulerDrvUpPhoto');
const LibSchedulerDrvUpLocIdle = require('../library/LibSchedulerDrvUpLocIdle');
const LibSchedulerDrvBlastNotif = require('../library/LibSchedulerDrvBlastNotif');
const LibSchedulerGpsTrackerWakeUp = require('../library/LibSchedulerGpsTrackerWakeUp');
// START TESTING
const axios = require('axios').default;
const url = require('url');
const request = require('../config/request');
// END TESTING

Validator.useLang('en');

class WorkerController {

  /**
   * QUEUE
   */

  async add(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name, data } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
 
        return res.status(200).json(apiRes);
      }

      if (name === LibSchedulerReverseGeocode.name) {
        LibSchedulerReverseGeocode.runQueueScheduler({
          label: 'Reverse geocoding from gps tracker latlng',
        });
      } else if (name === LibQueueBlastOrder.name) {
        LibQueueBlastOrder.addQueue({
          ...data,
          label: 'Blast Order to Another Vendor',
          delay: 5000, // 600000 || 10 minute
        });
      } else if (name === LibSchedulerDrvUpLoc.name) {
        LibSchedulerDrvUpLoc.runQueueScheduler({
          label: 'Scheduler driver up location',
        });
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.runQueueScheduler({
          label: 'Scheduler driver up photo',
        });
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        LibSchedulerDrvUpLocIdle.runQueueScheduler({
          label: 'Scheduler driver up location idle',
        });
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        LibSchedulerDrvBlastNotif.runQueueScheduler({
          label: 'Scheduler driver blast notif',
        });
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        LibSchedulerGpsTrackerWakeUp.runQueueScheduler({
          label: 'Scheduler gps tracker wakeup',
        });
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success add queue';
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  async getJobs(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
 
        return res.status(200).json(apiRes);
      }

      let gets = undefined;
      if (name === LibSchedulerReverseGeocode.name) {
        gets = await LibSchedulerReverseGeocode.getJobs();
      } else if (name === LibQueueBlastOrder.name) {
        gets = await LibQueueBlastOrder.getJobs();
      } else if (name === LibSchedulerDrvUpLoc.name) {
        gets = await LibSchedulerDrvUpLoc.getJobs();
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.getJobs();
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        gets = await LibSchedulerDrvUpLocIdle.getJobs();
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        gets = await LibSchedulerDrvBlastNotif.getJobs();
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        gets = await LibSchedulerGpsTrackerWakeUp.getJobs();
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success get jobs';
      apiRes.data = gets;
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  async getRepeatableJobs(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
 
        return res.status(200).json(apiRes);
      }

      let gets = undefined;
      if (name === LibSchedulerReverseGeocode.name) {
        gets = await LibSchedulerReverseGeocode.getRepeatableJobs();
      } else if (name === LibQueueBlastOrder.name) {
        gets = await LibQueueBlastOrder.getRepeatableJobs();
      } else if (name === LibSchedulerDrvUpLoc.name) {
        gets = await LibSchedulerDrvUpLoc.getRepeatableJobs();
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.getRepetableJobs();
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        gets = await LibSchedulerDrvUpLocIdle.getRepeatableJobs();
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        gets = await LibSchedulerDrvBlastNotif.getRepeatableJobs();
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        gets = await LibSchedulerGpsTrackerWakeUp.getRepeatableJobs();
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success get repeatable jobs';
      apiRes.data = gets;
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  async resume(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
 
        return res.status(200).json(apiRes);
      }

      if (name === LibSchedulerReverseGeocode.name) {
        LibSchedulerReverseGeocode.resumeQueue();
      } else if (name === LibQueueBlastOrder.name) {
        LibQueueBlastOrder.resumeQueue();
      } else if (name === LibSchedulerDrvUpLoc.name) {
        LibSchedulerDrvUpLoc.resumeQueue();
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        LibSchedulerDrvUpLocIdle.resumeQueue();
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.resumeQueue();
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        LibSchedulerDrvBlastNotif.resumeQueue();
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        LibSchedulerGpsTrackerWakeUp.resumeQueue();
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success resume';
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  async pause(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
 
        return res.status(200).json(apiRes);
      }

      if (name === LibSchedulerReverseGeocode.name) {
        LibSchedulerReverseGeocode.pauseQueue();
      } else if (name === LibQueueBlastOrder.name) {
        LibQueueBlastOrder.pauseQueue();
      } else if (name === LibSchedulerDrvUpLoc.name) {
        LibSchedulerDrvUpLoc.pauseQueue();
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.pauseQueue();
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        LibSchedulerDrvUpLocIdle.pauseQueue();
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        LibSchedulerDrvBlastNotif.pauseQueue();
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        LibSchedulerGpsTrackerWakeUp.pauseQueue();
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success pause job';
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  async drain(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
 
        return res.status(200).json(apiRes);
      }

      if (name === LibSchedulerReverseGeocode.name) {
        LibSchedulerReverseGeocode.drainQueue();
      } else if (name === LibQueueBlastOrder.name) {
        LibQueueBlastOrder.drainQueue();
      } else if (name === LibSchedulerDrvUpLoc.name) {
        LibSchedulerDrvUpLoc.drainQueue()
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.drainQueue();
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        LibSchedulerDrvUpLocIdle.drainQueue()
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        LibSchedulerDrvBlastNotif.drainQueue()
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        LibSchedulerGpsTrackerWakeUp.drainQueue()
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success drain queue';
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  async obliterate(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
 
        return res.status(200).json(apiRes);
      }

      if (name === LibSchedulerReverseGeocode.name) {
        LibSchedulerReverseGeocode.obliterateQueue();
      } else if (name === LibQueueBlastOrder.name) {
        LibQueueBlastOrder.obliterateQueue();
      } else if (name === LibSchedulerDrvUpLoc.name) {
        LibSchedulerDrvUpLoc.obliterateQueue();
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.obliterateQueue();
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        LibSchedulerDrvUpLocIdle.obliterateQueue();
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        LibSchedulerDrvBlastNotif.obliterateQueue();
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        LibSchedulerGpsTrackerWakeUp.obliterateQueue();
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success obliterateQueue queue';
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  /**
   * WORKERS
   */

  async start(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
 
        return res.status(200).json(apiRes);
      }

      // just work if before this set have waiting list, so new queue will not be processed
      if (name === LibSchedulerReverseGeocode.name) {
        LibSchedulerReverseGeocode.setWorker();
      } else if (name === LibQueueBlastOrder.name) {
        LibQueueBlastOrder.setWorker();
      } else if (name === LibSchedulerDrvUpLoc.name) {
        LibSchedulerDrvUpLoc.setWorker();
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.setWorker();
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        LibSchedulerDrvUpLocIdle.setWorker();
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        LibSchedulerDrvBlastNotif.setWorker();
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        LibSchedulerGpsTrackerWakeUp.setWorker();
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success start worker';
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  async shutdown(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();
      const { name } = req.body;

      // input validation
      const input = {
        name,
      };
      const rulesInput = {
        name: 'required|string',
      };
      const isInputValid = new Validator(input, rulesInput);
      if (isInputValid.fails()) {
        apiRes = JSON.parse(JSON.stringify(response[422]));
        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
        return res.status(200).json(apiRes);
      }

      if (name === LibSchedulerReverseGeocode.name) {
        LibSchedulerReverseGeocode.workerShutDown();
      } else if (name === LibQueueBlastOrder.name) {
        LibQueueBlastOrder.workerShutDown();
      } else if (name === LibSchedulerDrvUpLoc.name) {
        LibSchedulerDrvUpLoc.workerShutDown();
      } else if (name === LibSchedulerDrvUpPhoto.name) {
        LibSchedulerDrvUpPhoto.workerShutDown();
      } else if (name === LibSchedulerDrvUpLocIdle.name) {
        LibSchedulerDrvUpLocIdle.workerShutDown();
      } else if (name === LibSchedulerDrvBlastNotif.name) {
        LibSchedulerDrvBlastNotif.workerShutDown();
      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
        LibSchedulerGpsTrackerWakeUp.workerShutDown();
      } else {
        apiRes = JSON.parse(JSON.stringify(response[404]));
        return res.status(200).json(apiRes);
      }

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success shutdown worker';
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      return res.status(500).json(apiRes);
    }
  }

  /**
   * DO THE PROCESS VIA REQUEST
   */

  async revgeo(req, res) {
    let apiRes = {};
    try {
      const now = moment().unix();

      // input validation
      // const input = { };
      // const rulesInput = { };
      // const isInputValid = new Validator(input, rulesInput);
      // if (isInputValid.fails()) {
      //   apiRes = JSON.parse(JSON.stringify(response[422]));
      //   apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
      //   return res.status(200).json(apiRes);
      // }

      let params = new url.URLSearchParams({
        lat: req.body.lat,
        lon: req.body.lon,
        format: 'geojson',
      });
      const axInstance = axios.create();
      axios.defaults.timeout = 3000;
      axios.defaults.crossDomain = true;
      // respReverseGeo = await axios({
      //   url: request.osm_reverse_geo.urlFull,
      //   method: request.osm_reverse_geo.method,
      //   params: params,
      //   timeout: 3000,
      //   responseType: 'json',
      // });
      let respReverseGeo = await axInstance.get(request.osm_reverse_geo.urlFull + '?' + params.toString(), {
        timeout: 3000,
      });

      // success response
      apiRes = JSON.parse(JSON.stringify(response[200]));
      apiRes.meta.message = 'success reverse geocode';
      apiRes.meta.data = respReverseGeo.data;
      return res.status(200).json(apiRes);
    } catch (e) {
      apiRes = JSON.parse(JSON.stringify(response[500]));
      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
      // apiRes.debug = e.response.data;
      return res.status(500).json(apiRes);
    }
  }

}

const object = new WorkerController();

module.exports = object;