// Data preparation for fetching geigeractivity data
// rxf 2022-06-24

import {returnOnError} from "../utilities/reporterror.js";
import { calcRange, getActData, getAvgData, getLongAvg } from "../actions/getsensorData.js"
import checkParams from "../utilities/checkparams.js";
import { setoptionfromtable } from "../utilities/chartoptions.js"
import {DateTime} from 'luxon'
import { fetchgeigerAVGData } from "../databases/mongo.js";
import { translate as trans } from '../routes/api.js'



const geigeractFilter = (data, opts, actual) => {
    let erg = {}
    erg.sid = opts.sensorid
    erg.sname = opts.sname
    erg.values = []
    for (let x of data.values) {
        let entry = {}
        entry.datetime = x.datetime
        if(actual) {
            entry.cpm = x.counts_per_minute,
            entry.uSvh = x.counts_per_minute / 60 * opts.factor
        } else {
            entry.cpmAvg = x.counts_per_minute,
            entry.uSvhAvg = x.counts_per_minute / 60 * opts.factor
        }
        erg.values.push(entry)
    }
    return erg
}

const getgeigerDWMData = async (opts) => {
    if(opts.avg === 1) {
        const erg = await getActData(opts)
        return erg
    } else {
        const erg = await fetchgeigerAVGData(opts)
        return erg
    }
}

const  factorTable = [
    {name: 'SBM-20', factor: 1 / 2.47},
    {name: 'SBM-19', factor: 1 / 9.81888},
    {name: 'Si22G', factor: 0.081438},
    {name: 'J306', factor: 0.06536}
]

const getfactor = (name) => {
    const typ = name.slice((10))
    for(const x of factorTable) {
        if (x.name === typ) {
            return 1 / 60 * x.factor
        }   
    }
    return 1
}


export const getgeigerData = async (params, possibles, props) => {
    let ret = {err: null}

    let {opts, erro} = checkParams(params, {
        mandatory:[
            {name:'sensorid', type: 'int'},
        ],
        optional: possibles
    })
    // To be compatible with old API:
    if (opts.out === 'csv') {
        opts.csv = true
    }
    if (erro) {
        return returnOnError(ret, erro, getNoiseData.name)
    }

    opts.factor = getfactor(props.name[0].name)
    opts.span = setoptionfromtable(opts.span, 1)
    opts.daystart = setoptionfromtable(opts.daystart, false)
    opts.avg = setoptionfromtable(opts.avg, 1)
    opts.moving = setoptionfromtable(opts.moving, false)
    let {start, stop} = calcRange(opts)             // calc time range
    opts.start = start
    opts.stop = stop
    let erg = await getgeigerDWMData(opts)           // get the data
    ret = {
        err: erg.err,
        options: {
            sid: opts.sensorid,
            indoor: props.location[0].indoor,
            span: opts.span,
            start: DateTime.fromISO(opts.start.slice(7)),
            data: opts.data,
            count: erg.values.length,
            avg: opts.avg,
            moving: opts.moving
        },
        values: erg.values,
    }
    if(ret.values.length === 0) {
        ret.err = trans('NODATA')
    }
    return ret
}

/*


    let erg = { err: null, data: {}}

    let params = {
        sensorid: opts.sensorid,
        avg: opts.avg,
        datetime: opts.start
    }
    if (opts.what === 'oneday') {
        params.span = 1
    } else if (opts.what === 'oneweek') {
        params.span = 7
    } else {
        params.span = 31
        params.moving = false
        params.avg = 1440
    }
    let { data, err } = await getAvgData(params)
    if (err != null) {
        return returnOnError(erg, err, getgeigerData.name)
    }
    erg.data.geigermovavg = geigeractFilter(data, opts, false)
    if (opts.what === 'oneday') {
        const { data, err} = await getActData(params)
        if (err != null) {
            return returnOnError(erg, err, getgeigerData.name)
        }
        erg.data.geigeractual = geigeractFilter(data, opts, true)
    }
    if(opts.climatesid && ((opts.what === 'oneday') || (opts.what === 'oneweek'))) {
        params.sensorid = opts.climatesid
        params.avg = 10
        const { data, err} = await getAvgData(params)
        if (err != null) {
            return returnOnError(erg, err, getgeigerData.name)
        }
        data.sid = opts.climatesid
        data.sname = opts.climatesname
        erg.data.climate = data
    }
    return erg
}
*/