'use strict';

const moment = require('moment-timezone');

const db = require('../../models/index');
const Op = require('sequelize').Op;

const { incidentType, UI_TIMEZONE, DEFAULT_DATE_FORMAT, integrationServiceErrors } = require('../../constants/constants');

const { fetchAllMembers } = require('../officeRnD/members');
const { fetchOffices, fetchResources } = require('../officeRnD/resources');

const getUnlockedIncidents = (startDate, endDate, memberId) => {
    const attributes = ['id', 'memberId', 'resourceId', 'bookingStart', 'bookingEnd', 'incidentLevel', 'incidentLevelPrice'];

    const filters = {};

    if (startDate && endDate) {
        filters.bookingStart = {
            [Op.and]: {
                [Op.gte]: startDate.utc().toISOString(),
                [Op.lte]: endDate.utc().toISOString(),
            }
        }
    }

    if (memberId){
        filters.memberId = memberId;
    }

    return db.unlockedIncident.findAll({
        attributes,
        where: filters,
        sort: [
            ['bookingStart', 'ASC']
        ]
    });
};

const getUnscheduledIncidents = (startDate, endDate, memberId) => {
    const attributes = [
        'id',
        'memberId',
        'resourceId',
        'bookingStart',
        'bookingEnd',
        'doorLockEventTimestamp',
        'doorLockEventType',
        'timeIntervalsToCharge',
        'chargePrice',
        'totalChargeFee'
    ];

    const filters = {};

    if (startDate && endDate) {
        filters.bookingStart = {
            [Op.and]: {
                [Op.gte]: startDate.utc().toISOString(),
                [Op.lte]: endDate.utc().toISOString(),
            }
        }
    }

    if (memberId){
        filters.memberId = memberId;
    }

    return db.unscheduledIncident.findAll({
        attributes,
        where: filters,
        sort: [
            ['bookingStart', 'ASC']
        ]
    });
};

const formatTime = (timestamp) => {
    return moment.tz(timestamp, UI_TIMEZONE).format('MM/DD/YYYY hh:mm a');
};

const getAllDoorLockIncidents = (dateRange, memberId) => {
    return new Promise ((resolve, reject) => {
        let startDate, endDate;

        if (dateRange.startDate && dateRange.endDate){
            startDate = moment.tz(dateRange.startDate, DEFAULT_DATE_FORMAT, UI_TIMEZONE);
            endDate = moment.tz(dateRange.endDate, DEFAULT_DATE_FORMAT, UI_TIMEZONE);

            if (!startDate.isValid() || !endDate.isValid() || endDate.isBefore(startDate)){
                reject(integrationServiceErrors.INVALID_DATE_RANGE);
                return;
            }
        }

        const dataFetchJobs = [fetchAllMembers(), fetchOffices(), fetchResources(), getUnlockedIncidents(startDate, endDate, memberId), getUnscheduledIncidents(startDate, endDate, memberId)];

        Promise.all(dataFetchJobs)
            .then((data) => {
                const members = data[0];
                const offices = data[1];
                const resources = data[2];
                const unlockedIncidents = data[3];
                const unscheduledIncidents = data[4];

                const membersMap = {};
                const officesMap = {};
                const resourcesMap = {};

                members.forEach((member) => membersMap[member.memberId] = member);
                offices.forEach((office) => officesMap[office.officeId] = office);
                resources.forEach((resource) => resourcesMap[resource.resourceId] = resource);

                const allIncidents = [];

                unlockedIncidents.forEach((unlockedIncident) => {
                    allIncidents.push({
                        incidentId: unlockedIncident.id,
                        memberId: unlockedIncident.memberId,
                        memberName: membersMap[unlockedIncident.memberId].name,
                        resourceName: resourcesMap[unlockedIncident.resourceId].resourceName,
                        officeName: officesMap[resourcesMap[unlockedIncident.resourceId].officeId].officeName,
                        bookingStart: formatTime(unlockedIncident.bookingStart),
                        bookingEnd: formatTime(unlockedIncident.bookingEnd),
                        incidentType: incidentType.UNLOCKED_INCIDENT,
                        incidentLevel: unlockedIncident.incidentLevel,
                        incidentPrice: unlockedIncident.incidentLevelPrice,
                    });
                });

                unscheduledIncidents.forEach((unscheduledIncident) => {
                    allIncidents.push({
                        incidentId: unscheduledIncident.id,
                        memberId: unscheduledIncident.memberId,
                        memberName: membersMap[unscheduledIncident.memberId].name,
                        resourceName: resourcesMap[unscheduledIncident.resourceId].resourceName,
                        officeName: officesMap[resourcesMap[unscheduledIncident.resourceId].officeId].officeName,
                        bookingStart: formatTime(unscheduledIncident.bookingStart),
                        bookingEnd: formatTime(unscheduledIncident.bookingEnd),
                        incidentType: incidentType.UNSCHEDULED_INCIDENT,
                        timeIntervalsToCharge: unscheduledIncident.timeIntervalsToCharge,
                        chargePrice: unscheduledIncident.chargePrice,
                        totalChargeFee: unscheduledIncident.totalChargeFee,
                    });
                });

                resolve(allIncidents);
            })
            .catch((error) => reject(error));
    });
};

module.exports = {
    getUnlockedIncidents,
    getUnscheduledIncidents,
    getAllDoorLockIncidents,
};