const SandboxedJobMQ = require('bullmq').SandboxedJob;
const LibWinston = require('../library/LibWinston');
const moment = require('moment');
const axios = require('axios').default;
const url = require('url');
const request = require('../config/request');
const GpsTracksModels = require('../models/GpsTracksModels');
const RegionModels = require('../models/RegionModels');

const schedulerName = process.env.REDIS_SCHEDULER_REVERSE_GEO;
const Logger = LibWinston.initialize(schedulerName);

module.exports = async (job) => {
  try {
    Logger.log('info', `${schedulerName} running: ${JSON.stringify(job.opts)}`);

    // (async function() {
      try {
        let loop = process.env.SCHEDULE_REVERSE_GEO_MAX_LOOP;
        for (let x = 0; x < loop; x++) {
          // let tracks = [];
          let tracks = await GpsTracksModels.get2ForReverseGeo(1);
          for (let i = 0; i < tracks.length; i++) {
            let now = moment().unix();
            let updtData = {};
            let respReverseGeo = null;
            try {
              const sameAddr = await GpsTracksModels.select2Address(tracks[i].latitude, tracks[i].longitude);
              if (sameAddr.length > 0) {
                let addrData = {
                  device_id: tracks[i].device_id,
                  master_id: tracks[i].id,
                  type: sameAddr[0].type,
                  lat: tracks[i].latitude,
                  lng: tracks[i].longitude,
                  country_id: sameAddr[0].country_id,
                  country_code: sameAddr[0].country_code,
                  country_text: sameAddr[0].country_text,
                  state_id: sameAddr[0].state_id,
                  state_text: sameAddr[0].state_text,
                  city_id: sameAddr[0].city_id,
                  city_text: sameAddr[0].city_text,
                  district_id: sameAddr[0].district_id,
                  district_text: sameAddr[0].district_text,
                  village_id: sameAddr[0].village_id,
                  village_text: sameAddr[0].village_text,
                  postcode: sameAddr[0].postcode,
                  streets: sameAddr[0].streets,
                  fulladdress: encodeURIComponent(decodeURIComponent(sameAddr[0].fulladdress)),
                  type_reverse_geo: sameAddr[0].type_reverse_geo,
                  stts_reverse_geo: GpsTracksModels.STTS_REVERSE_GEO_SC,
                  log_reverse_geo: sameAddr[0].log_reverse_geo,
                  crt: now,
                  crt_format: moment.unix(now).format('YYYY-MM-DD HH:mm:ss'),
                };
                GpsTracksModels.create2Address(addrData);
                updtData.stts_reverse_geo = GpsTracksModels.STTS_REVERSE_GEO_SC;
                await GpsTracksModels.update2(tracks[i].id, updtData);
                continue;
              }

              let params = new url.URLSearchParams({
                lat: tracks[i].latitude,
                lon: tracks[i].longitude,
                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,
              //   responseType: 'json',
              // });
              respReverseGeo = await axInstance.get(request.osm_reverse_geo.urlFull + '?' + params.toString(), {
                timeout: 3000,
              });
              let respData = respReverseGeo.data || {};
              if (respReverseGeo.status == 200) {
                if (respData.features.length < 1) {
                  GpsTracksModels.create2Address({
                    device_id: tracks[i].device_id,
                    master_id: tracks[i].id,
                    lat: tracks[i].latitude,
                    lng: tracks[i].longitude,
                    stts_reverse_geo: GpsTracksModels.STTS_REVERSE_GEO_LOST,
                    log_reverse_geo: JSON.stringify(respData),
                    crt: now,
                    crt_format: moment.unix(now).format('YYYY-MM-DD HH:mm:ss'),
                  });
                  updtData.stts_reverse_geo = GpsTracksModels.STTS_REVERSE_GEO_LOST;
                  await GpsTracksModels.update2(tracks[i].id, updtData);
                } else {
                  let respAddr = respData.features[0].properties.address;
                  let addrData = {
                    device_id: tracks[i].device_id,
                    master_id: tracks[i].id,
                    lat: tracks[i].latitude,
                    lng: tracks[i].longitude,
                    country_id: GpsTracksModels.DEFAULT_COUNTRY_ID,
                    country_code: respAddr.country_code,
                    country_text: (respAddr.country) ? respAddr.country.toUpperCase() : respAddr.country || null,
                    state_id: null,
                    city_id: null,
                    district_id: null,
                    village_id: null,
                    postcode: respAddr.postcode,
                    fulladdress: encodeURIComponent(respData.features[0].properties.display_name),
                    stts_reverse_geo: GpsTracksModels.STTS_REVERSE_GEO_SC,
                    log_reverse_geo: (respData.features[0].properties) ? JSON.stringify(respData.features[0].properties) : null,
                    crt: now,
                    crt_format: moment.unix(now).format('YYYY-MM-DD HH:mm:ss'),
                  };
                  if (respAddr.state || respAddr.city) {
                    addrData.state_text = respAddr.region || respAddr.state || respAddr.state_district || respAddr.county || respAddr.city || '';
                    addrData.state_text = (addrData.state_text) ? addrData.state_text.toUpperCase() : addrData.state_text || null;
                    addrData.state_text = addrData.state_text || null;
                  }
                  if (respAddr.city_district || respAddr.city) {
                    addrData.city_text = respAddr.city_district || respAddr.city || '';
                    addrData.city_text = (addrData.city_text) ? addrData.city_text.toUpperCase() : addrData.city_text || null;
                    addrData.city_text = addrData.city_text || null;
                  }
                  if (respAddr.suburb || respAddr.subdistrict) {
                    addrData.district_text = respAddr.suburb || respAddr.subdistrict || respAddr.subdivision || '';
                    addrData.district_text = (addrData.district_text) ? addrData.district_text.toUpperCase() : addrData.district_text || null;
                    addrData.district_text = addrData.district_text || null;
                  }
                  if (respAddr.village) {
                    addrData.village_text = respAddr.village || respAddr.neighbourhood || '';
                    addrData.village_text = (addrData.village_text) ? addrData.village_text.toUpperCase() : addrData.village_text || null;
                    addrData.village_text = addrData.village_text || null;
                  }
                  if (respAddr.amenity || respAddr.road || respAddr.city_block) {
                    addrData.streets = '';
                    addrData.streets += (respAddr.amenity) ? respAddr.amenity + ', ' : '';
                    addrData.streets += (respAddr.road) ? respAddr.road + ', ' : '';
                    addrData.streets += (respAddr.house_number) ? respAddr.house_number + ', ' : '';
                    addrData.streets += (respAddr.house_name) ? respAddr.house_name + ', ' : '';
                    addrData.streets += (respAddr.city_block) ? respAddr.city_block + ', ' : '';
                    addrData.streets += addrData.streets || null;
                    if (addrData.streets) {
                      addrData.streets = encodeURIComponent(addrData.streets.slice(0, -2));
                    }
                  }
                  
                  let byAll = await RegionModels.whereLike({
                    nmProvinsiKel: addrData.state_text,
                    nmKotamadyaKel: addrData.city_text,
                    nmKecamatanKel: addrData.district_text,
                    nmKelurahan: addrData.village_text,
                  });
                  if (byAll.length > 1) {
                    addrData.state_id = byAll[0].kodeProv;
                    addrData.city_id = byAll[0].kodeKab;
                    addrData.district_id = byAll[0].kodeKec;
                    addrData.village_id = byAll[0].kodeKel;
                  }
      
                  let byKel = await RegionModels.whereLike({
                    nmKelurahan: addrData.village_text,
                  });
                  if (byAll.length < 1 && byKel.length > 0) {
                    addrData.state_id = byKel[0].kodeProv;
                    addrData.city_id = byKel[0].kodeKab;
                    addrData.district_id = byKel[0].kodeKec;
                    addrData.village_id = byKel[0].kodeKel;
                  }
      
                  if (addrData.state_id === null) {
                    let byPr = await RegionModels.whereLike({ nmProvinsiKel: addrData.state_text });
                    if (byPr.length > 0) { addrData.state_id = byPr[0].kodeProv; }
                  }
      
                  if (addrData.state_id !== null && addrData.city_id === null) {
                    let byKt = await RegionModels.whereLike({ nmKotamadyaKel: addrData.city_text });
                    if (byKt.length > 0) { addrData.city_id = byKt[0].kodeKab; }
                  }
                  
                  if (addrData.state_id !== null && addrData.city_id !== null && addrData.district_id === null) {
                    let byKc = await RegionModels.whereLike({ nmKecamatanKel: addrData.district_text });
                    if (byKc.length > 0) { addrData.district_id = byKc[0].kodeKec; }
                  }
      
                  if (addrData.state_id !== null && addrData.city_id !== null && addrData.district_id !== null && addrData.village_id === null) {
                    let byKl = await RegionModels.whereLike({ nmKelurahan: addrData.village_text });
                    if (byKl.length > 0) { addrData.village_id = byKl[0].kodeKel; }
                  }

                  GpsTracksModels.create2Address(addrData).catch((e) => {
                    Logger.log('error', `${schedulerName} running_error: ${JSON.stringify(e, Object.getOwnPropertyNames(e))}`);
                  });
                  updtData.stts_reverse_geo = GpsTracksModels.STTS_REVERSE_GEO_SC;
                  await GpsTracksModels.update2(tracks[i].id, updtData);
                }
              } else {
                GpsTracksModels.create2Address({
                  device_id: tracks[i].device_id,
                  master_id: tracks[i].id,
                  lat: tracks[i].latitude,
                  lng: tracks[i].longitude,
                  stts_reverse_geo: GpsTracksModels.STTS_REVERSE_GEO_ER,
                  log_reverse_geo: JSON.stringify(respData),
                  crt: now,
                  crt_format: moment.unix(now).format('YYYY-MM-DD HH:mm:ss'),
                });
                updtData.stts_reverse_geo = GpsTracksModels.STTS_REVERSE_GEO_ER;
                await GpsTracksModels.update2(tracks[i].id, updtData);
              }
            } catch (e) {
              let respData = {}
              if (respReverseGeo) {
                if (respReverseGeo.status != 200) {
                  respData.data = respReverseGeo.data;
                } else {
                  respData.msg = e.message;
                }
              } else if (typeof e.response != 'undefined') {
                respData.data = e.response;
              } else {
                respData.msg = e.message;
              }
              GpsTracksModels.create2Address({
                device_id: tracks[i].device_id,
                master_id: tracks[i].id,
                lat: tracks[i].latitude,
                lng: tracks[i].longitude,
                stts_reverse_geo: GpsTracksModels.STTS_REVERSE_GEO_ER,
                log_reverse_geo: JSON.stringify(respData),
                crt: now,
                crt_format: moment.unix(now).format('YYYY-MM-DD HH:mm:ss'),
              });
              updtData.stts_reverse_geo = GpsTracksModels.STTS_REVERSE_GEO_ER;
              await GpsTracksModels.update2(tracks[i].id, updtData);
            }
            job.updateProgress(1);
          }
        }        
      } catch (e) {
        console.error(e);
        Logger.log('error', `${schedulerName} error: ${JSON.stringify(e)}`);
      }
    // })();

    return {
      type: 'success',
      message: 'success do reverse geocoding',
      data: null,
    };
  } catch (e) {
    return {
      type: 'error',
      message: e.message,
      e: e,
    };
  }
};