const moment = require('moment');
const models = require('../models');
const { Room } = models;

const Utils = {
    processElasticSearchData: async (results, checkGetStatus0 = false) => {
        let rooms = await Room.findAll({
            attributes: ['room_id', 'person_sensor']
        });

        let responseData = {};
        let lastData = {};

        if (results.length) {
            // group data from elastic search by sensor id
            let group = {};
            results.forEach(function (item) {
                if (typeof group[item._source.sensor_id] == "undefined") {
                    group[item._source.sensor_id] = [
                        {
                            timestamp: item._source.timestamp,
                            status: item._source.status
                        }
                    ];
                } else {
                    let oldData = group[item._source.sensor_id];
                    oldData.push({
                        timestamp: item._source.timestamp,
                        status: item._source.status
                    });
                    group[item._source.sensor_id] = oldData;
                }
            });

            // calculate time range with status for sensor id
            for(const sensorId in group) {
                let sensorData = group[sensorId];
                let sensorDataLength = sensorData.length;
                let data = [];
                let status = '';

                for(let j=0; j < sensorDataLength; j++) {
                    const item = sensorData[j];
                    if (status !== item.status) {
                        let startTime = item.timestamp;
                        if (data.length > 0 && typeof data[data.length-1].endTime == "undefined") {
                            data[data.length-1].endTime = startTime;
                        }
                        data.push({startTime, status: item.status});
                    }
                    status = item.status;
                    if (j + 1 < sensorDataLength && item.timestamp.substr(0,10) !== sensorData[j + 1].timestamp.substr(0,10)) {
                        data[data.length -1].endTime = sensorData[j].timestamp;
                        status = '';
                    }
                }
                if (data.length > 0){
                    data[data.length -1].endTime = sensorData[sensorDataLength-1].timestamp;
                }

                responseData[sensorId.toUpperCase()] = data;
            }
        }

       // map data sensor id for room
        let objectRoom = {};
        rooms.forEach(function (room) {
            let values = responseData[room.person_sensor.toUpperCase()];
            if (typeof values != "undefined") {
                let roomId = room.room_id;

                if (typeof objectRoom[roomId] == "undefined") {
                    objectRoom[roomId] = values;
                } else {
                    objectRoom[roomId] = [...objectRoom[roomId], ...values];
                }
            }
        });

        for(const roomId in objectRoom) {
            let values = objectRoom[roomId];
            let result = [], last;
            let min = values[0].startTime;
            let max = values[0].startTime;

            // sort time range in ascending order
            values.sort(function(a, b) {
                if (a.startTime > b.startTime) return 1;
                if (a.startTime < b.startTime) return -1;
                return 0;
            });

            // calculate time range has status 1
            values.forEach(function (r) {
                if (values.length == 1 && r.status == 0) {
                    result.push(r);
                    return;
                }

                if (r.endTime > max) {
                    max = r.endTime;
                }

                if (r.status === 0 ) {
                    return;
                } else {
                    if (!last || r.startTime > last.endTime) {
                        result.push(last = r);
                    } else if (r.endTime > last.endTime) {
                        last.endTime = r.endTime;

                    }
                }
            });

            if(checkGetStatus0) {
                //handle min max status 0
                let minMaxStatus = [
                    {
                        startTime: min,
                        status: 0,
                        endTime: result[0].startTime
                    },
                    {
                        startTime: result[result.length - 1].endTime,
                        status: 0,
                        endTime: max
                    }
                ];

                let addObject = [];
                for (let i = 1; i < result.length; i++) {
                    let startTime = result[i - 1].endTime;
                    let endTime = result[i].startTime;
                    let status = 0;

                    addObject.push({startTime: startTime, status: status, endTime: endTime});
                }
                result = [...result, ...minMaxStatus, ...addObject];
            }

            result = result.map(function (r) {
                r.minute = moment(r.endTime).diff(moment(r.startTime), 'minutes');
                return r;
            });
            lastData[roomId] = result;
        }

        return lastData;
    },
    handleParamElasticSearch: (date) => {
        const timeFrom = moment(date).hours(process.env.FROM_HOUR).format('YYYY-MM-DDTHH:mm:ss+0900');
        const timeTo = moment(date).hours(process.env.TO_HOUR).format('YYYY-MM-DDTHH:59:59+0900');
        const prefix = 'fluentd-iot-enocean-*';

        return {'timeFrom':timeFrom, 'timeTo': timeTo, 'prefix': prefix };
    },
};

module.exports = Utils;