// Fetch the actual (= newest) data out of the dbase to show it on the map
import {DateTime} from "luxon"
import {logit} from "../utilities/logit.js"
import * as mongo from "../databases/mongo.js"
import {reportError, returnOnError} from "../utilities/reporterror.js"
import * as ERR from "../utilities/errortexts.js"


// Default distance for center search ( in km)
const DEFAULT_DISTANCE = 10


// Relations between types and value type
const vtype2measurement = {
    P1: 'pm', P2: 'pm', P0: 'pm',
    temperature: 'thp', humidity: 'thp', pressure: 'thp',
    noise_LAeq: 'noise',
    counts_per_minute: 'radioactivity'
};


// find first value type from measurement
const getfieldfromtype = (typ) => {
    for (const [key, value] of Object.entries(vtype2measurement)) {
        if (value === typ) {
            return key
        }
    }
    return ' '
}


export const getData4map = async (params) => {
    let start = DateTime.now()
    let retur = { err: null, data: { params: params} }

    // check parameters
    if ((params.type === undefined) || (params.type === '')) {
        return returnOnError(retur, ERR.NOTYP, getData4map.name)
    }
    const typ = params.type
    let poly = []
    let south = null, north = null, east = null, west = null, center = null
    let distance = DEFAULT_DISTANCE
    if (!((params.box === undefined) || (params.box == ""))) {
        const box = params.box
        if (!((box === undefined) || (box === ' ') || (box === 'null'))) {
            south = parseFloat(box.south)
            north = parseFloat(box.north)
            east = parseFloat(box.east)
            west = parseFloat(box.west)
            logit(`getData4map: S=${south}  N=${north}  E=${east}  W=${west}`)
        }
    }
    if (!((params.poly === undefined)  || (params.poly === ' '))){
        poly = JSON.parse(params.poly)
    }
    if (params.center !== undefined) {
        center = params.center
        if ((params.distance !== undefined) &&
            (params.distance >= 1) && (params.distance <= 1000)) {
            distance = params.distance
        }
    }
    const aktData = []
    let lastDate = 0
    let query = {type: typ}

    // if polyline or box were given, set query
    if (poly.length !== 0) {                                // polyline given
        query.location = {
            $geoWithin: {
                $geometry: {
                    type: "Polygon",
                    coordinates: [poly],
                }
            }
        }
    } else if (south !== null) {                            // box given
        query["location.loc"] = {
            $geoWithin: {
                $box: [
                    [west, south],
                    [east, north]
                ]
            }
        }
    } else if (center !== null) {                            // center point given
        query["location.loc"] = {
            $nearSphere: {
                $geometry: {
                    type: "Point",
                    coordinates: center
                },
                $maxDistance: distance * 1000
            }
        }
    }
    // depending of the type find the measurement field to fetch
    const vtype = getfieldfromtype(typ)

    // fetch mapdata from mongodb
    try {
        let { values, err } = await mongo.readMapdata(query, 0)
        if(err) {
            return returnOnError(retur, ERR.NOSENSFOUND, getData4map.name)
        }
        for (let item of values) {
            const oneAktData = {
                location: item.location.loc.coordinates,
                id: item._id,
                name: item.name,
                indoor: item.location.indoor,
                value: Math.round(item.value[vtype] * 100) / 100
            }
            let now = new Date().getTime()
            let diff = now - item.timestamp
            if (diff >= 7 * 24 * 3600 * 1000) {
                oneAktData.value = -2
            } else if (diff >= 2 * 3600 * 1000) {
                oneAktData.value = -1
            }
            if (item.timestamp > lastDate) {
                lastDate = item.timestamp
            }
            aktData.push(oneAktData)
        }
        logit(`Query duration: ${start.diffNow('seconds').toObject().seconds * -1} sec`)
        retur.data.lastDate = lastDate
        retur.data.valuetype = vtype
        retur.data.count = aktData.length
        retur.data.values = aktData
        return retur
    }
    catch(e) {
        return returnOnError(retur, `catch\n${e}`, getData4map.name)
    }
}