/*

Il microcontrollore degli MPPT (PIC24/dsPIC33 a virgola fissa) trasmette interi a 16 bit. Per
inviare dati decimali piu precisi, il dato viene moltiplicato per un valore definito.
conversionFactors mappa i valori di conversione usati, in modo tale che il codice riceve i dati e li divide il fattore di conversione.

*/
const conversionsFactors = {
  voltageInput: 10,        // tensione ingresso [V]    es: 296  -> 29.6 V
  currentInput: 100,       // corrente ingresso [A]    es: 1100 -> 11.00 A
  powerInput: 10,          // potenza ingresso [W]     es: 3260 -> 326.0 W
  voltageOutput: 10,       // tensione uscita [V]      es: 864  -> 86.4 V
  currentOutput: 100,      // corrente uscita [A]      es: 380  -> 3.80 A
  powerOutput: 10,         // potenza uscita [W]       es: 3110 -> 311.0 W
  temperaturePhase1: 10,   // temperatura fase 1 [°C]
  temperaturePhase2: 10,   // temperatura fase 2 [°C]
  chargeCapacity: 100,     // capacita' caricata [Ah]  es: 1234 -> 12.34 Ah
};

// Flag del registro Status1 (registro 4): mappa bit -> codice operativo
const status1Flags = {
  0: 'PwrEna',     // Power stage abilitato via software
  1: 'ChgEna',     // Ponte Pin1-Pin8 inserito (enable hardware)
  2: 'ChgOk',      // Condizioni di ricarica OK
  3: 'PwrOn',      // Stadio di potenza acceso (eroga corrente)
  4: 'StorMod',    // Modalita' storage attiva
  5: 'FloatMod',   // Modalita' float (mantenimento)
  6: 'CtrlEna',    // Algoritmo MPPT abilitato
  7: 'CCapRst',    // Reset contatore Ah
  8: 'Ph1Ena',     // Fase 1 abilitata
  9: 'Ph2Ena',     // Fase 2 abilitata
  10: 'QREna',     // Quasi-Resonant Mode
  11: 'DirMPPT',   // Direzione algoritmo MPPT
};

// Flag del registro Warning (registro 6): mappa bit -> codice di errore/warning
const errorsFlags = {
  0: 'fault',
  1: 'vi_under_voltage_protection',
  2: 'vi_low_voltage',                  // MPPT in standby
  3: 'vi_over_voltage_protection',
  4: 'li_over_current_protection',
  5: 'under_minimum_battery_voltage',
  6: 'over_maximum_battery_voltage',
  7: 'current_to_battery_over_max',     // protezione hw a 7A verso batteria
  8: 'internal_hardware_protection',
  9: 'over_temperature_protection',     // sopra 120 °C
  10: 'memory_flash_read_error',
};

/*
  Indirizzi dei registri Poweren da leggere via UART (comando READ singolo registro).

  ATTENZIONE: i valori marcati con "(da verificare)" sono dedotti dalla struttura del
  protocollo e NON sono confermati dal manuale fornito. Per ottenere la mappa completa e
  certa, interrogare l'MPPT con i comandi GET_REG_NAMES (102) / GET_REG_VALUES (101) tramite
  DataCOM, oppure consultare la tabella registri del manuale (Doc. 40.0000.206) e correggere
  qui i numeri. I valori confermati dalla documentazione sono indicati come "(confermato)".
*/
const registerAddresses = {
  deviceAddress: 1,    // Addr - indirizzo del dispositivo (confermato: usato per discovery)
  status1: 4,          // St1  - flag di stato            (confermato: "registro 4")
  warning: 6,          // Warn - flag di warning/errore   (confermato: "registro 6")
  chargeCapacity: 7,   // Chg_Cap - Ah caricati           (da verificare)
  voltageInput: 16,    // Vi - tensione ingresso          (da verificare)
  currentInput: 17,    // Ii - corrente ingresso          (da verificare)
  voltageOutput: 18,   // Vo - tensione uscita            (da verificare)
  currentOutput: 19,   // Io - corrente uscita            (da verificare)
  powerInput: 20,      // Pi - potenza ingresso           (confermato)
  powerOutput: 21,     // Po - potenza uscita             (confermato)
  temperature1: 35,    // T1 - temperatura fase 1         (confermato)
  temperature2: 36,    // T2 - temperatura fase 2         (confermato)
};

/*
  Elenco ordinato dei registri da interrogare ad ogni ciclo di polling per ciascun MPPT.
  Si leggono solo i registri che alimentano i path SignalK; Pi/Po non sono inclusi perche'
  la potenza viene calcolata come Vi*Ii e Vo*Io (come nella versione CAN).
*/
const pollRegisters = [
  registerAddresses.status1,
  registerAddresses.warning,
  registerAddresses.voltageInput,
  registerAddresses.currentInput,
  registerAddresses.voltageOutput,
  registerAddresses.currentOutput,
  registerAddresses.chargeCapacity,
  registerAddresses.temperature1,
  registerAddresses.temperature2,
];

/*
  Costanti del frame del protocollo seriale Poweren (UART).
  Struttura pacchetto:
    [SOF][DST][SRC][0x00][DLEN][DATA...][CHK_HI][CHK_LO][EOF]
  - SOF = 0x42 ('B')
  - SRC della GUI/host = 0xFF
  - DST = indirizzo MPPT (0x00 = qualsiasi, es. 50 = MPPT di default)
  - CHK = sum(DATA) & 0xFFFF in big-endian
  - EOF = 0x0D
*/
const serialProtocol = {
  startOfFrame: 0x42,     // SOF
  sourceHost: 0xFF,       // SRC host/GUI
  endOfFrame: 0x0D,       // EOF
  addressAny: 0x00,       // DST = qualsiasi dispositivo (usato per discovery)
  headerLength: 5,        // SOF + DST + SRC + 0x00 + DLEN
  tailLength: 3,          // CHK_HI + CHK_LO + EOF
  // Comandi (scritti nel registro 2)
  commands: {
    reset: 99,
    defaultValues: 100,
    getRegValues: 101,
    getRegNames: 102,
    getRegUnits: 103,
    getRegTypes: 104,
    getFirmwareVersion: 120,
  },
};

// Parametri di default della porta seriale (Waveshare USB-UART, 8N1)
const serialDefaults = {
  baudRate: 115200,
  dataBits: 8,
  parity: 'none',
  stopBits: 1,
  // Linee di controllo: alcuni adapter (es. FTDI FT232R) resettano il target all'apertura.
  // L'esempio di discovery Poweren funzionante le imposta entrambe a true.
  dtr: true,
  rts: true,
  // Tempo di assestamento dopo l'apertura della porta prima di iniziare a trasmettere
  openSettleMs: 250,
};

// Timeout e retry per le transazioni sincrone (richiesta -> risposta)
const transactionTiming = {
  timeoutMs: 500,
  retries: 5,
  retryDelayMs: 100,
};

module.exports = {
  conversionsFactors,
  status1Flags,
  errorsFlags,
  registerAddresses,
  pollRegisters,
  serialProtocol,
  serialDefaults,
  transactionTiming,
};