"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log = require("./log");
const CallChain = require("./callchain");
const Processor = require("./processor");
const config = require("./config");
class ClientEntry {
}
class MissingEventProcessor extends Processor.AProcessor {
    constructor() {
        super("MissingEventProcessor");
        this.clientMap = new Map();
        this.timer = setInterval(() => {
            this.clientMap.forEach((value, key) => {
                let currentTime = new Date().getTime();
                let elapsedTime = currentTime - value.lastEvent;
                log.debug(`MissingEventProcessor: Checking ${key}, elapsed: ${elapsedTime / 1000}, avg. delay: ${value.avgDelay / 1000}`);
                if (value.alarmState && ((value.lastAlarmMessage + config.dict.alarmRepeatPeriod * 1000) < currentTime)) {
                    value.lastAlarmMessage = currentTime;
                    value.alarmMessageCounter += 1;
                    log.sendAlarmMail('Repeated Alarm', `Missing Event Detected: ${key}, repeated: ${value.alarmMessageCounter}, elapsed: ${elapsedTime / 1000}, avg. delay: ${value.avgDelay / 1000}`);
                }
                if ((!value.alarmState) && ((value.avgDelay != 0) && (elapsedTime > (value.avgDelay * 3)))) {
                    log.sendAlarmMail('Alarm', `Missing Event Detected: ${key}, elapsed: ${elapsedTime / 1000}, avg. delay: ${value.avgDelay / 1000}`);
                    value.alarmState = true;
                    value.lastAlarmMessage = currentTime;
                }
            });
        }, config.dict.checkPeriod * 1000);
    }
    process(message) {
        let client = message.metadata.client;
        log.info(`MissingEventProcessor: Event for client ${client}`);
        let currentTime = new Date().getTime();
        if (this.clientMap.has(client)) {
            let clientEntry = this.clientMap.get(client);
            clientEntry.client = client;
            clientEntry.delay = currentTime - clientEntry.lastEvent;
            clientEntry.lastEvent = currentTime;
            clientEntry.count += 1;
            if (clientEntry.count >= 1) {
                clientEntry.delaySum += clientEntry.delay;
                clientEntry.avgDelay = clientEntry.delaySum / clientEntry.count;
            }
            if (clientEntry.alarmState) {
                log.sendAlarmMail('Release', `Event received again: ${client}`);
                clientEntry.alarmMessageCounter = 0;
            }
            clientEntry.alarmState = false;
            this.clientMap.set(client, clientEntry);
            log.info(`MissingEventProcessor: Entry for ${client} updated`);
        }
        else {
            let clientEntry = new ClientEntry();
            clientEntry.client = client;
            clientEntry.lastEvent = currentTime;
            clientEntry.delay = 0;
            clientEntry.count = -1;
            clientEntry.delaySum = 0;
            clientEntry.avgDelay = 0;
            clientEntry.alarmState = false;
            clientEntry.alarmMessageCounter = 0;
            this.clientMap.set(client, clientEntry);
            log.info(`MissingEventProcessor: Entry for ${client} inserted`);
        }
    }
}
class MissingEventDetector extends CallChain.ABaseChainItem {
    constructor() {
        super("MissingEventDetector");
        this.missingEventProcessor = new MissingEventProcessor();
    }
    func(message) {
        this.missingEventProcessor.in(message);
        return message;
    }
}
exports.MissingEventDetector = MissingEventDetector;
//# sourceMappingURL=missingeventdetector.js.map