require("dotenv").config({ path: "../.env" });
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 { stringify } = require("flatted");

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

const go = async () => {
	try {
		Logger.log("info", `${schedulerName} running: ${moment().format("YYYY-MM-DD HH:mm:ss")}`);
		// (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++) {
					console.log("tracks[i] :", tracks[i].id, tracks[i].device_id, tracks[i].latitude, tracks[i].longitude);
					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()
						const axInstance = axios.create({
							proxy: {
								host: process.env.PROXY_URL,
								port: process.env.PROXY_PORT,
							},
						});
						axios.defaults.timeout = 10000;
						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: 10000,
						// });
						respReverseGeo = await axInstance.get(request.osm_reverse_geo.urlFull + "?" + params.toString(), {
							timeout: 10000,
							headers: {
								"User-Agent": "movana-fleet-management/1.0 (emirsyafmun@gmail.com)",
							},
						});
						console.log("respReverseGeo: ", respReverseGeo.data || null);
						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;
						}

						console.log("typeof respData.data:", typeof respData.data);
						console.log("isPlainObject:", Object.prototype.toString.call(respData.data) === "[object Object]");
						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.data),
							log_reverse_geo: stringify(respData.data),
							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) {
			console.error(e);
			Logger.log("error", `${schedulerName} error: ${JSON.stringify(e)}`);
		}
		// })();

		Logger.log("info", `${schedulerName} success do reverse geocoding ${moment().format("YYYY-MM-DD HH:mm:ss")}`);
	} catch (e) {
		Logger.log("error", `${schedulerName} error: ${JSON.stringify(e)}`);
	}
	return true;
};

const index = async () => {
	while (1 == 1) {
		await go();
		await new Promise((r) => setTimeout(r, 300));
	}
};

index();