/* Interface for MongoDB
*/
import  { MongoClient } from  'mongodb'
import { logit, logerror } from '../utilities/logit.js'
import { DateTime } from 'luxon'
import {returnOnError} from "../utilities/reporterror.js";

// const nodemailer = require('nodemailer');

let MONGOHOST = process.env.MONGOHOST;
let MONGOPORT = process.env.MONGOPORT;
let MONGOAUTH = process.env.MONGOAUTH;
let MONGOUSRP = process.env.MONGOUSRP;
let MONGOBASE =  process.env.MONGOBASE;

if (MONGOHOST === undefined) { MONGOHOST = 'localhost';}
if (MONGOPORT === undefined) { MONGOPORT =  27097; }
if (MONGOAUTH === undefined) { MONGOAUTH =  'false'; }
if (MONGOBASE === undefined) { MONGOBASE =  'allsensors'; }

let MONGO_URL = 'mongodb://'+MONGOHOST+':'+MONGOPORT;  	// URL to mongo database
if (MONGOAUTH === 'true') {
    MONGO_URL = 'mongodb://'+MONGOUSRP+'@' + MONGOHOST + ':' + MONGOPORT + '/?authSource=' + MONGOBASE;          // URL to mongo database
}

export const properties_collection = 'pptest'

let statistics = {}
let client

export const connectMongo = async () => {
    try {
        logit(`Try to connect to ${MONGO_URL}`)
//        let client = await MongoClient.connect(MONGO_URL, { useNewUrlParser: true , useUnifiedTopology: true })
        let client = await MongoClient.connect(MONGO_URL)
        logit(`Mongodbase connected to ${MONGO_URL}`)
        return client
    }
    catch(error){
        throw(error)
    }
}

export const closeMongo = async (client) => {
    client.close()
}

const listDatabases = async (client) => {
    let databasesList = await client.db().admin().listDatabases();

    console.log("Databases:");
    databasesList.databases.forEach(db => console.log(` - ${db.name}`));
}

/* ***************************************************
// READ routines
******************************************************/

// Read properties from the database
export const readProperties = async (query, limit = 0) => {
    let ret = {err: null, properties: null}
        client = await connectMongo()
    try {
        if ("sid" in query) {                               // if sid is given, read property for sid
            ret.properties = await client.db(MONGOBASE).collection(properties_collection).findOne({_id: query.sid})
        } else {                                            // otherwise read props corresponding to query
            ret.properties = await client.db(MONGOBASE).collection(properties_collection).find(query).limit(limit).toArray()
        }
    } catch (e) {
        ret.err = e
    }
    finally {
            await closeMongo(client)
            client = null
    }
    return ret
}

// read mapdata from database
export const readMapdata = async (query, limit) => {
    let ret = {err: null, mapdata: []}
    client = await connectMongo()
    try {
        ret.mapdata = await client.db(MONGOBASE).collection("mapdata").find(query).limit(limit).toArray()
    } catch (e) {
        ret.err = e
    }
    finally {
        await closeMongo(client)
        client = null
    }
    return ret
}


export const getallProperties = async (coll, query) => {
    let ret = {err: null, properties: []}
    client = await connectMongo()
    try {
        ret.properties = await client.db(MONGOBASE).collection(coll)
            .find(query).toArray()
    } catch (e) {
        ret.err = e
    }
    finally {
        await closeMongo(client)
        client = null
    }
    return ret
}


export const getOneproperty = async (sid) => {
    let ret = {error: false}
    client = await connectMongo()
    try {
        ret.properties = await client.db(MONGOBASE).collection("properties_collection")
            .findOne({_id: sid})
    } catch (e) {
        ret =  {error: true, errortext: e}
    }
    finally {
        await closeMongo(client)
        client = null
    }
    return ret
}


export const doAggregate = async (coll, query, conn, clos) => {
    let ret = {error: false}
    if (conn) {
        client = await connectMongo()
    }
    try {
        ret.values = await client.db(MONGOBASE).collection(coll).aggregate(query).toArray()
    } catch (e) {
        ret =  {error: true, errortext: e}
    }
    finally {
        if (clos) {
            await closeMongo(client)
            client = null
        }
    }
    return ret
}


export const writeOneproperty = async (client, prop) => {
    try {
        let result = await client.db(MONGOBASE).collection("properties_collection")
            .insertOne(prop)
    } catch(e) {
        if (e.code === 11000) {
            return false
        } else {
            throw(e)
        }
    }
    return true
}

export const writeProperties = async (client, props) => {
    let start = DateTime.now();
    if (props.new.length !== 0) {
        try {
            let result = await client.db(MONGOBASE).collection("properties_collection")
                .insertMany(props.new)
        } catch (e) {
            console.error(e)
        }
    }
    if (props.loc.length !== 0) {
        try {
            for (let item of props.loc) {
                let result = await client.db(MONGOBASE).collection("properties_collection")
                    .updateOne({_id: item._id}, {
                        $set: {location_id: item.location_id},
                        $push: {location: { $each: [item.location[0]], $position: 0}}
                    })
            }
        } catch (e) {
            console.error(e)
        }
    }
    if (props.sname.lenth !== 0) {
        try {
            for (let item of props.sname) {
                let result = await client.db(MONGOBASE).collection("properties_collection")
                    .updateOne({_id: item._id}, {
                        $set: {name: item.name, since: item.since}
                    })
            }
        } catch (e) {
            console.error(e)
        }
    }
    statistics.writePropsTime = DateTime.now().diff(start, ['seconds']).toObject().seconds
    logit(`Write properties to mongoDB: ${statistics.writePropsTime} sec.`)
}

export const writeDataArray = async (data, collection, conn, clos) => {
    let start = DateTime.now();
    let result
    if (conn) {
        client = await connectMongo()
    }
     try {
        result = await client.db(MONGOBASE).collection(collection)
            .insertMany(data)
    } catch (e) {
        console.error(e)
    } finally {
        if(clos) {
            await closeMongo(client)
            client = null
        }
    }
    statistics.writeDataTime = DateTime.now().diff(start, ['seconds']).toObject().seconds
    logit(`Write Data to mongoDB: ${statistics.writeDataTime} sec.`)
    return result
}

export const writeStatistic = async (client, stat) => {
    let start = DateTime.now();
    let entry = { timestamp: new Date(), ...stat }
    try {
        let result = await client.db(MONGOBASE).collection("statistics")
            .insertOne(entry)
    } catch (e) {
        console.error(e)
    }
    statistics.writeStatisticTime = DateTime.now().diff(start, ['seconds']).toObject().seconds
    logit(`Write statistics to mongoDB: ${statistics.writeStatisticTime} sec.`)
}

export const readAKWs = async (options) => {
    let ret = {values: { akws: [], th1_akws: []}, err: null}
    let erg = []
    client = await connectMongo()
    try {
       let docs = await client.db(MONGOBASE).collection("akws")
            .find().toArray()
        if(docs == null) {
            return returnOnError(ret, 'akws - docs == null', readAKWs.name)
        }
        logit(`getawkdata: data fetched from akws, length= ${docs.length}`);
        ret.values.akws = docs
        let docs1 = await client.db(MONGOBASE).collection("th1_akws")
            .find().toArray()
        if(docs1 == null) {
            return returnOnError(ret, 'th1_akws - docs == null', readAKWs.name)
        }
        logit(`getawkdata: data fetched from th1_akws, length= ${docs1.length}`)
        ret.values.th1_akws = docs1
    } catch (e) {
        return returnOnError(ret, e, readAKWs.name)
    }
    finally {
        await closeMongo(client)
        client = null
    }
    return ret
}

/*
async function getMAPaktData(db,opt) {
    let box = opt.box;
    if ((box == "") || (box == undefined)) {
        return {"avgs": [], "lastDate": null};
    }
    var south = parseFloat(box[0][1]);
    var north = parseFloat(box[1][1]);
    var east = parseFloat(box[1][0]);
    var west = parseFloat(box[0][0]);
    var collection = db.collection('mapdata');                         // use the mapdata collection
    var aktData = [];
    var now = moment();
    var lastDate = 0;
    let loc;
    loc = {
        location: {
            $geoWithin: {
                $box: [
                    [west, south],
                    [east, north]
                ]
            }
        },
        name: { $regex : "^Laerm|^DNMS"},
    }
    let docs = await collection.find(loc).toArray();
//        console.log(docs);
    for (var i = 0; i < docs.length; i++) {
        var item = docs[i];
        var oneAktData = {};
        oneAktData['location'] = item.location.coordinates;
        oneAktData['id'] = item._id;                                // ID des Sensors holen
        oneAktData['lastSeen'] = item.values.datetime;
        oneAktData['indoor'] = item.indoor;
        var dati = item.values.datetime;
        var dt = new Date(dati);
        if ((now - dt) >= 31 * 24 * 3600 * 1000) {                            // älter als 1 Monat ->
            oneAktData['noise_max'] = -2;                                 // -2 zurückgeben
        } else if ((now - dt) >= 3600 * 1000) {                          // älter als 1 Stunde ->
            oneAktData['noise_max'] = -1;                                 // -1 zurückgeben
        } else {
            oneAktData['noise_max'] = -5;                                 // bedutet -> nicht anzeigen
            if (item.values.hasOwnProperty('noise_LA_max')) {
                oneAktData['noise_max'] = item.values.noise_LA_max.toFixed(0);    // und merken
            }
            if (dati > lastDate) {
                lastDate = dati;
            }
        }
        aktData.push(oneAktData);                                   // dies ganzen Werte nun in das Array
    }
    return {"avgs": aktData, "lastDate": lastDate};                                              // alles bearbeitet _> Array senden
};

 */