/**
 * @file valveClass.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 
....
*/


//load local dependencies #NOTE: Vul hier nog de juiste dependencies in als meer nodig of sommige niet nodig
const EventEmitter = require('events');
const Logger = require('../../generalFunctions/helper/logger');
const State = require('../../generalFunctions/helper/state/state');
const Predict = require('../../predict/dependencies/predict/predict_class');
const { MeasurementContainer } = require('../../generalFunctions/helper/measurements/index');

//load all config modules #NOTE: Vul hier nog de juiste dependencies in als meer nodig of sommige niet nodig 
const defaultConfig = require('./valveConfig.json');
const ConfigUtils = require('../../generalFunctions/helper/configUtils');

//load registration utility #NOTE: Vul hier nog de juiste dependencies in als meer nodig of sommige niet nodig
const ChildRegistrationUtils = require('../../generalFunctions/helper/childRegistrationUtils');

class Valve { 
    constructor(valveConfig = {}, stateConfig = {}) { 
        this.emitter = new EventEmitter(); // nodig voor ontvangen en uitvoeren van events emit() en on() --> Zien als internet berichten (niet bedraad in node-red)
        this.configUtils = new ConfigUtils(defaultConfig); // nodig voor het ophalen van de default configuaratie 
        this.config = this.configUtils.initConfig(valveConfig); //valve configurations die bij invoer in node-red worden gegeven  
        
        // Initialize measurements
        this.measurements = new MeasurementContainer();
        this.child = {}; // object to hold child information so we know on what to subscribe
        
        // Init after config is set
        this.logger = new Logger(this.config.general.logging.enabled, this.config.general.logging.logLevel, this.config.general.name);
        this.state = new State(stateConfig, this.logger); // Init State manager and pass logger
        this.state.stateManager.currentState = "operational"; // Set default state to operational
        
        this.kv = 0; //default
        this.rho =  1,225 //dichtheid van lucht standaard
        this.T = 293; // temperatuur in K standaard
        this.downstreamP = 0.54 //hardcodes for now --> assumed to be constant watercolumn and deltaP diffuser
        this.currentMode = this.config.mode.current;

        // wanneer hij deze ontvangt is de positie van de klep verandererd en gaat hij de updateposition functie aanroepen wat dan alle metingen en standen gaat updaten 
        this.state.emitter.on("positionChange", (data) => {
          this.logger.debug(`Position change detected: ${data}`);
          this.updatePosition()}); //To update deltaP 

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

        //replace v_curve loadspecs with config file afterwards   !!!!!!!!!!
        this.vCurve = this.loadSpecs().v_curve
        this.predictKv = new Predict({curve:this.vCurve}); // load valve size (x : ctrl , y : kv relationship) 
    }

      // -------- Config -------- //
    updateConfig(newConfig) {
        this.config = this.configUtils.updateConfig(this.config, newConfig);
    }

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

    async handleInput(source, action, parameter) {
        if (!this.isValidSourceForMode(source, this.currentMode)) {
          let warningTxt = `Source '${source}' is not valid for mode '${this.currentMode}'.`;
          this.logger.warn(warningTxt);
          return {status : false , feedback: warningTxt};
        }
    
        this.logger.info(`Handling input from source '${source}' with action '${action}' in mode '${this.currentMode}'.`);
        try {
          switch (action) {
            case "execSequence":
              await this.executeSequence(parameter);
              break;
            case "execMovement": // past het setpoint aan - movement van klep stand
              await this.setpoint(parameter);
              break;
            case "emergencyStop":
              this.logger.warn(`Emergency stop activated by '${source}'.`);
              await this.executeSequence("emergencyStop");
              break;
            case "statusCheck":
              this.logger.info(`Status Check: Mode = '${this.currentMode}', Source = '${source  }'.`);
              break;
            default:
              this.logger.warn(`Action '${action}' is not implemented.`);
              break;
          }
          this.logger.debug(`Action '${action}' successfully executed`);
          return {status : true , feedback: `Action '${action}' successfully executed.`};
        } catch (error) {
          this.logger.error(`Error handling input: ${error}`);
        }
        
    }

    setMode(newMode) {
        const availableModes = defaultConfig.mode.current.rules.values.map(v => v.value);
        if (!availableModes.includes(newMode)) {
          this.logger.warn(`Invalid mode '${newMode}'. Allowed modes are: ${availableModes.join(', ')}`);
          return;
        }
    
        this.currentMode = newMode;
        this.logger.info(`Mode successfully changed to '${newMode}'.`);
    }

  loadSpecs(){ //static betekend dat die in andere classes kan worden aangeroepen met const specs = Valve.loadSpecs()
    //lateron based on valve caracteristics --> then it searches for right valve
    let specs = {
        supplier : "Binder",
        type : "HDCV",
        units:{ 
            Nm3: { "temp": 20, "pressure" : 1.01325 , "RH" : 0 },  // according to DIN 
            v_curve : { x : "% stroke", y : "Kv value"} ,
        },
        v_curve: { 
            125:  // valve size 
            { 
                x:[0,10,20,30,40,50,60,70,80,90,100], //stroke in %
                y:[0,18,50,95,150,216,337,564,882,1398,1870], //Kv value expressed in m3/h
            },
            150:  // valve size 
            { 
                x:[0,10,20,30,40,50,60,70,80,90,100], //stroke in %
                y:[0,25,73,138,217,314,490,818,1281,2029,2715], //oxygen transfer rate expressed in gram o2 / normal m3/h / per m
            },
            400:  // valve size 
            { 
                x:[0,10,20,30,40,50,60,70,80,90,100], //stroke in %
                y:[0,155,443,839,1322,1911,2982,4980,7795,12349,16524], //oxygen transfer rate expressed in gram o2 / normal m3/h / per m
            },
        }
    }
    
    return specs;
  } 

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

    const sequence = this.config.sequences[sequenceName];

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

    if (this.state.getCurrentState() == "operational" && sequenceName == "shutdown") {
      this.logger.info(`Machine will ramp down to position 0 before performing ${sequenceName} sequence`);
      await this.setpoint(0);
    }

    this.logger.info(` --------- Executing sequence: ${sequenceName} -------------`);

    for (const state of sequence) {
      try {
        await this.state.transitionToState(state);
        // Update measurements after state change

      } catch (error) {
        this.logger.error(`Error during sequence '${sequenceName}': ${error}`);
        break; // Exit sequence execution on error
      }
    }
    }

    async setpoint(setpoint) {

    try {
      // Validate setpoint
      if (typeof setpoint !== 'number' || setpoint < 0) {
        throw new Error("Invalid setpoint: Setpoint must be a non-negative number.");
      }

      // Move to the desired setpoint
      await this.state.moveTo(setpoint);

    } catch (error) {
      console.error(`Error setting setpoint: ${error}`);
    }
  }

  

  // NOTE: Omdat met zeer kleine getallen wordt gewerkt en er kwadraten in de formule zitten kan het zijn dat we alles *1000 moeten doen 
  updateDeltaPKlep(q,kv,downstreamP,rho,temp){
      //q must be in Nm3/h
      //temp must be in K
      //q must be in m3/h

      //downstreamP must be in bar so transfer from mbar to bar
      downstreamP = downstreamP / 1000;
      //convert downstreamP to absolute bar 
      downstreamP += 1.01325;
  
      //calculate deltaP
      let deltaP = ( q**2 * rho * temp ) / ( 514**2 * kv**2 * downstreamP);
      
      //convert deltaP to mbar
      deltaP = deltaP * 1000;

      // Synchroniseer deltaP met het Valve-object
      this.deltaPKlep = deltaP

      // Opslaan in measurement container
      this.measurements.type("pressure").variant("predicted").position("delta").value(deltaP);
      this.logger.info('DeltaP updated to: ' + deltaP);

      this.emitter.emit('deltaPChange', deltaP); // Emit event to notify valveGroupController of deltaP change
      this.logger.info('DeltaPChange emitted to valveGroupController');
    }

     
  // Als er een nieuwe flow door de klep komt doordat de pompen harder zijn gaan pompen, dan update deze functie dit ook in de valve attributes en measurements
  //NOTE: samenvoegen met updateFlow als header node er is 
  updateFlowKlep(q){
    //q must be in Nm3/h
    // Opslaan in measurement container van valve object
    this.measurements.type("flow").variant("predicted").position("downstream").value(q);
    this.logger.info('FlowKlep updated to: ' + q);  
    this.logger.info('Calculating new deltaP based on new flow');
    this.updateDeltaPKlep(q,this.kv,this.downstreamP,this.rho,this.T); //update deltaP based on new flow
  }

  updatePosition() { //update alle parameters nadat er een verandering is geweest in stand van klep
    if (this.state.getCurrentState() == "operational" || this.state.getCurrentState() == "accelerating" || this.state.getCurrentState() == "decelerating") {
      
      this.logger.debug('Calculating new deltaP');
      const currentPosition = this.state.getCurrentPosition();
      const currentFlow = this.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue(); // haal de flow op uit de measurement containe
      //const valveSize = 125; //NOTE: nu nog hardcoded maar moet een attribute van de valve worden
      this.predictKv.fDimension = 125; //load valve size by defining fdimension in predict class
      //const vCurve = this.loadSpecs().v_curve[valveSize]; // haal de curve op van de valve
      //const Spline = require('cubic-spline'); // spline library -> nodig om kv waarde te benaderen op curve
      const x = currentPosition; // dit is de positie van de klep waarvoor we delta P willen berekenen
      const y = this.predictKv.y(x); // haal de waarde van kv op uit de spline

      this.kv = y; //update de kv waarde in de valve class
      if (this.kv < 0.1){
        this.kv = 0.1; //minimum waarde voor kv
      }
      this.logger.debug(`Kv value for position valve ${x} is ${this.kv}`); // log de waarde van kv
      this.updateDeltaPKlep(currentFlow,this.kv,this.downstreamP,this.rho,this.T); //update deltaP

    }
  }

  getOutput() { 

    // Improved output object generation
    const output = {};
    //build the output object
    this.measurements.getTypes().forEach(type => {
      this.measurements.getVariants().forEach(variant => {
        this.measurements.getPositions().forEach(position => {

        const value = this.measurements.type(type).variant(variant).position(position).getCurrentValue(); //get the current value of the measurement
        
      
        if (value != null) {
          output[`${position}_${variant}_${type}`] = value;
        }
      });
      });
    });

    //fill in the rest of the output object
    output["state"] = this.state.getCurrentState();
    output["percentageOpen"] = this.state.getCurrentPosition();
    output["moveTimeleft"] = this.state.getMoveTimeLeft();
    output["mode"] = this.currentMode;

    //this.logger.debug(`Output: ${JSON.stringify(output)}`);

    return output;
  }

}

module.exports = Valve;