/**
 * @file gate.js
 *
 * Permission is hereby granted to any person obtaining a copy of this software 
 * and associated documentation files (the "Software"), to use it for personal 
 * or non-commercial purposes, with the following restrictions:
 *
 * 1. **No Copying or Redistribution**: The Software or any of its parts may not 
 *    be copied, merged, distributed, sublicensed, or sold without explicit 
 *    prior written permission from the author.
 * 
 * 2. **Commercial Use**: Any use of the Software for commercial purposes requires 
 *    a valid license, obtainable only with the explicit consent of the author.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, 
 * OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
 * SOFTWARE.
 *
 * Ownership of this code remains solely with the original author. Unauthorized 
 * use of this Software is strictly prohibited.
 *
 * @summary A class to interact and manipulate machines with a non-euclidian curve
 * @description A class to interact and manipulate machines with a non-euclidian curve
 * @module ggc
 * @exports ggc
 * @version 2.0.0
 * @since 0.1.0
 * 
 * Author:
 * - Rene De Ren
 * Email:
 * - rene@thegoldenbasket.nl
 * 
*/

//load local dependencies
const EventEmitter = require('events');
const Logger = require('../../../generalFunctions/helper/logger');
const { MeasurementContainer } = require('../../../generalFunctions/helper/measurements/index');
const Interpolation = require('../../../predict/dependencies/predict/interpolation');
//load all config modules
const defaultConfig = require('./ggcConfig.json');
const ConfigUtils = require('../../../generalFunctions/helper/configUtils');
//load registration utility
const ChildRegistrationUtils = require('../../../generalFunctions/helper/childRegistrationUtils');

class Ggc {


  /*-------------------               Construct and set vars               -------------------*/
  constructor(ggcConfig = {}) {

    //basic setup
    this.emitter = new EventEmitter();  // Own EventEmitter
    this.configUtils = new ConfigUtils(defaultConfig);
    this.config = this.configUtils.initConfig(ggcConfig);

    // Initialize measurements
    this.measurements = new MeasurementContainer();
    this.interpolation = new Interpolation();
    this.child = {}; // object to hold child
    this.actuators = []; // object to hold actuators
    this.abortController = null;  // new abort controller for aborting async tasks

    // Init after config is set
    this.logger = new Logger(this.config.general.logging.enabled, this.config.general.logging.logLevel, this.config.general.name);
    this.mode = this.config.mode.current;

    this.move_delay = this.config.settings.moveDelay ; //define opening delay in seconds between 2 gates
    this.state = "gateGroupClosed"; //define default starting state of the gates

    //auto close
    this.autoClose = true;
    this.autoCloseTime = this.config.settings.autoClose;
    this.autoCloseCnt = 0;

    //protection sensor
    this.safetySensor = false;
    this.retryDelay = this.config.settings.retryDelay; // in seconds
    this.closeAttempt = 0;
    this.maxCloseAttempts = this.config.settings.maxRetries ;
    this.safetySensorCnt = 0;
    

    //ground loop trigger
    this.ground_loop = false;
    this.ground_loop_start = Date.now();
    this.ground_loop_open = 10; //define time in seconds for when the ground loop should trigger a respons

    //define if something has gone through the gate
    this.goneThrough = false;

    //define if the gate is closed
    this.checkGateClosed = [false, false]; // gate 1 and gate 2

    /* time controlled functions*/
    //this.sleep = ms => new Promise(res => setTimeout(res, ms));

    this.childRegistrationUtils = new ChildRegistrationUtils(this); // Child registration utility
  }


    isValidSourceForMode(source, mode) {
        const allowedSourcesSet = this.config.mode.allowedSources[mode] || [];
        return allowedSourcesSet.has(source);
    }

    isValidActionForMode(action, mode) {
        const allowedActionsSet = this.config.mode.allowedActions[mode] || [];
        return allowedActionsSet.has(action);
    }

    sleep(ms, signal) {
        return new Promise((resolve, reject) => {
            const timer = setTimeout(resolve, ms);
            // only attach abort listener if a valid signal is provided
            if (signal && typeof signal.addEventListener === 'function') {
                signal.addEventListener('abort', () => {
                    clearTimeout(timer);
                    reject(new Error('aborted'));
                });
            }
        });
    }

    // -------- Sequence Handlers -------- //
    async executeSequence(name) {

        const sequence = this.config.sequences[name];
        const positions = this.actuators.map(a => a.state.getCurrentPosition());
        const states = this.actuators.map(a => a.state.getCurrentState());

        if (!sequence || sequence.size === 0) {
            this.logger.warn(`Sequence '${name}' not defined.`);
            return;
        }

        // Abort any prior sequence and start fresh
        this.abortController?.abort();
        this.abortController = new AbortController();
        const { signal } = this.abortController;

        if ( states.some(s => s !== "operational") && name !== "stop2gates" ) {
            this.logger.warn(`Actuators not operational, aborting sequence '${name}'.`);
            this.handleInput("parent", "execSequence", "stop2gates");
            this.sleep(1000).then(() => {
                this.handleInput("parent", "execSequence", name);
            });
            return;
        }

        try {
            for (const action of sequence) {

                this.transitionToSequence(action);

                //If someone has already called abort(), skip the delay
                if (signal.aborted) {
                    continue;
                }

                //otherwise, wait for the delay
                await this.sleep(this.move_delay * 1000, signal);
            }
        } catch (err) {
            if (err.message === 'aborted') {
                this.logger.debug(`Sequence '${name}' aborted mid-delay.`);
            } else {
                this.logger.error(`Error in sequence '${name}': ${err.stack}`);
            }
        } finally {
            // Clean up so we know no sequence is running
            this.abortController = null;
        }

    }


    async transitionToSequence(action) {
        this.logger.debug(`Executing action: ${action}`);
        const positions = this.actuators.map(a => a.state.getCurrentPosition());   
        const states = this.actuators.map(a => a.state.getCurrentState());
         
        // Perform actions based on the state
        switch (action) {
            case "openGate1":
                this.logger.debug("Opening gate 1");
                this.actuators[0].handleInput("parent", "execMovement", 100);
                this.checkGateClosed[0] = false;
                break;
            case "openGate2":
                this.logger.debug("Opening gate 2");
                this.actuators[1].handleInput("parent", "execMovement", 100);
                break;
            case "stopGate1":
                this.logger.debug("Stopping gate 1");
                // abort the delayed sleep, if any
                this.abortController?.abort();
                // immediately stop actuator 1
                this.actuators[0].stop();
                break;
            case "stopGate2":
                this.logger.debug("Stopping gate 2");
                // abort the delayed sleep, if any
                this.abortController?.abort();
                // immediately stop actuator 2
                this.actuators[1].stop();
                break;
            case "closeGate1":
                this.actuators[0].handleInput("parent", "execMovement", 0);
                break;
            case "closeGate2":
                this.actuators[1].handleInput("parent", "execMovement", 0);
                break;
            default:
                this.logger.warn(`Unknown state: ${state}`);
        }
    }

    async handleInput(source, action, parameter) {

        if (!this.isValidSourceForMode(source, this.mode)) {
            this.logger.warn(`Invalid source ${source} for mode ${this.mode}`);
            return;
        }

        if (!this.isValidActionForMode(action, this.mode)) {
            this.logger.warn(`Invalid action ${action} for mode ${this.mode}`);
            return;
        }

        switch (action) {
            case 'execSequence':
                this.executeSequence(parameter);
                break;
            case 'setMode':
                this.setMode(parameter);
                break;
            default:
                this.logger.warn(`Unknown action ${action}`);
        }

    }

    groundLoopAction(){
        if(this.ground_loop){
            //keep track of time
            this.ground_loop_time = Date.now() - this.ground_loop_trigger;
        }
        else{
            this.ground_loop_time = 0;
        }

        if(this.ground_loop_time >= ( this.ground_loop_open * 1000) ){
            this.openGates();
        }
    }

    updateMeasurement(variant, subType, value, position) {
        this.logger.debug(`---------------------- updating ${subType} ------------------ `);
        switch (subType) {
        case "power":
            // Update power measurement
            this.updatePower(variant, value, position);
            break;
        default:
            this.logger.error(`Type '${type}' not recognized for measured update.`);
            return;
        }
    }

    updatePower(variant,value,position) {
        switch (variant) {
        case ("measured"):
            // put value in measurements
            this.measurements.type("power").variant(variant).position("wire").value(value);
            this.eventUpdate();
            this.logger.debug(`Measured: ${value}`);
            break;

        default:
            this.logger.warn(`Unrecognized variant '${variant}' for update.`);
            break;
        }
    }

    eventUpdate() {
        // Gather raw data in arrays
        const positions = this.actuators.map(a => a.state.getCurrentPosition());
        const states    = this.actuators.map(a => a.state.getCurrentState());
        this.logger.debug(`States: ${JSON.stringify(states)}`);
        this.logger.debug(`Positions: ${JSON.stringify(positions)}`);
        const totPower  = this.measurements.type("power").variant("measured").position("wire").getCurrentValue();

        // Utility flags
        const allOperational   = states.every(s => s === "operational");
        const allAtOpen        = positions.every(p => p === 100);
        const allAtClosed      = positions.every(p => p === 0);
        const allAccelerating  = states.every(s => s === "accelerating");
        const allDecelerating  = states.every(s => s === "decelerating");
        const allStopped       = states.every(s => s === "operational") && positions.every( p => p !== 0 && p != 100); 
        const onlyGateOneAccelerating  = states[0] === "accelerating" && states[1] === "operational";
        const onlyGateTwoAccelerating  = states[1] === "accelerating" && states[0] === "operational";
        const onlyGateOneDecelerating  = states[0] === "decelerating" && states[1] === "operational";
        const onlyGateTwoDecelerating  = states[1] === "decelerating" && states[0] === "operational";
        const oneOpenOneClosed = allOperational && positions.some(p => p === 0) && positions.some(p => p === 100);

        // Threshold for “spike” detection (tune as needed)
        const SPIKE_THRESHOLD_1gate = 50;
        const SPIKE_THRESHOLD_2gates = 100; 
        const lowerPositionThreshold = 10; // 10% of the total range
        const upperPositionThreshold = 90; // 90% of the total range

        // When something is blocking the gate we need to reopen the gates (True means nothing is blocking)
        if (!this.safetySensor) {
            // always add 1 to the safety sensor counter
            this.safetySensorCnt++;

            //add 1 to the autoclose counter to check weither we dont exceedd the max retries
            if(this.autoClose) {
                this.autoCloseCnt++;
            }
            //check if the safety sensor is triggered and the gates are closing 
            if( allDecelerating || onlyGateOneDecelerating || onlyGateTwoDecelerating) {
                this.closeAttempt++;
                this.handleInput("parent", "execSequence", "stop2gates");
                this.logger.debug("something is blocking the gate, stopping actuators");
                this.sleep(1000).then(() => {
                    this.handleInput("parent", "execSequence", "open2gates");
                });
            }
        }

        // Detect if any single gate is decelerating into its stop
        if( onlyGateOneDecelerating ) {
            //check for power spike so we know the gate is closed
            if ( totPower > SPIKE_THRESHOLD_1gate ) {
                this.logger.debug("Gate 1 is decelerating into the stop (power spike)");
                //check flag for knowing if the gate is closed
                this.checkGateClosed[0] = true;
                this.closeAttempt = 0;
            }
        }

        if( allDecelerating || allAccelerating) {
            if( totPower > SPIKE_THRESHOLD_2gates && ( positions.some(p => p > lowerPositionThreshold) || positions.some(p => p < upperPositionThreshold) ) ) {
                this.logger.debug("Unexpected power spike detected");
                // stop the actuators
                this.handleInput("parent", "execSequence", "stop2gates");
            }
        }

        // Decide group state
        if (allAtOpen && allOperational) {
                this.state = "gateGroupOpened";
                //trigger auto close if count is smaller than max
            if( this.autoClose && this.autoCloseCnt < this.maxCloseAttempts && this.safetySensorCnt > 0) {
                this.sleep(this.autoCloseTime * 1000).then(() => {
                    this.handleInput("parent", "execSequence", "close2gates");
                    //reset the safetySensor count because we are automatically closing the gates and if its bigger than 0 it means some1 passed through it
                    this.safetySensorCnt = 0;
                });
            }
            this.logger.debug("Gates are open");
        }
        else if (allAtClosed && allOperational) {
            this.state = "gateGroupClosed";
            //after everything was closed and the auto close is enabled we need to reset the auto close count
            if(this.autoClose) {
                this.autoCloseCnt = 0;
            };
            this.logger.debug("Gates are closed");
        }
        else if (oneOpenOneClosed) {
            this.state = "oneGateOpenOneGateClosed";
            this.logger.debug("One gate open, one gate closed");
        }
        else if (allAccelerating) {
            this.state = "gateGroupAccelerating";
            this.logger.debug("Gates are accelerating");
        }
        else if (onlyGateOneAccelerating) {
            this.state = "gateOneAccelerating";
            this.logger.debug("Only gate 1 is accelerating");
        }
        else if (onlyGateTwoAccelerating) {
            this.state = "gateTwoAccelerating";
            this.logger.debug("Only gate 2 is accelerating");
        }
        else if (allDecelerating) {
            this.state = "gateGroupDecelerating";
            this.logger.debug("Gates are decelerating");
        }
        else if (onlyGateOneDecelerating) {
            this.state = "gateOneDecelerating";
            this.logger.debug("Only gate 1 is decelerating");
        }
        else if (onlyGateTwoDecelerating) {
            this.state = "gateTwoDecelerating";
            this.logger.debug("Only gate 2 is decelerating");
        }
        else if (allStopped) {
            this.state = "gateGroupStopped";
            this.logger.debug("Gates are stopped");
        }
        else {
            this.state = "unknown";
            this.logger.warn(`Unhandled combination: positions=${positions}, states=${states}`);
        }

        // if the gates are operational and close but we dont see the truely closed state then we need to nudge the gate to force the close
    
    }

    getOutput() {

        // Improved output object generation
        const output = {};

        //build the output object
        this.measurements.getTypes().forEach(type => {
          this.measurements.getVariants(type).forEach(variant => {
    
            const downstreamVal = this.measurements.type(type).variant(variant).position("downstream").getCurrentValue();
            const upstreamVal = this.measurements.type(type).variant(variant).position("upstream").getCurrentValue();
    
            if (downstreamVal != null) {
              output[`downstream_${variant}_${type}`] = downstreamVal;
            }
            if (upstreamVal != null) {
              output[`upstream_${variant}_${type}`] = upstreamVal;
            }
            if (downstreamVal != null && upstreamVal != null) {
              const diffVal = this.measurements.type(type).variant(variant).difference().value;
              output[`differential_${variant}_${type}`] = diffVal;
            }
          });
        });
    
        //fill in the rest of the output object
        output["mode"] = this.mode;
        output["totPower"] = this.power;
        //this.logger.debug(`Output: ${JSON.stringify(output)}`);
    
        return output;
    }

} // end of class

module.exports = Ggc;

/*
const ggcConfig = {
    general: {
        name: "TestGGC",
        logging: {
            enabled: true,
            logLevel: "debug"
        }
    },
    settings: {
        moveDelay: 3,
        autoClose: 5,
        retryDelay: 10,
        maxRetries: 5
    }
};

const ggc = new Ggc(ggcConfig);
const linearActuator = require('../../../linearActuator/dependencies/linearActuator/linearActuator');
const linActConfig = 
{
    general: {
        logging: {
            enabled: true,
            logLevel: "debug",
        }
    },
    settings: {
        moveDelay: 3,
        autoClose: 5,
        retryDelay: 10,
        maxRetries: 5
    }
};
const stateConfig = {
    general: {
        logging: {
            enabled: true,
            logLevel: "debug"
        }
    },
    movement: {
        speed: 0.1,
        mode: "staticspeed"
    },
    time: {
        starting: 0,
        warmingup: 0,
        stopping: 0,
        coolingdown: 0
    }
};

const gate1 = new linearActuator(linActConfig,stateConfig);
const gate2 = new linearActuator(linActConfig,stateConfig);

ggc.childRegistrationUtils.registerChild(gate1,"upstream");
ggc.childRegistrationUtils.registerChild(gate2,"downstream");


//open completely 2 gates inside an async IIFE
(async () => {
    await ggc.actuators[0].handleInput("parent","execSequence","startup");
    await ggc.actuators[1].handleInput("parent","execSequence","startup");

    ggc.handleInput("parent","execSequence","open2gates");
    await ggc.sleep(5000);
    ggc.handleInput("parent","execSequence","stop2gates");
    
})();
//*/