[External Converter]: OTH3600-GA-ZB from Ouellet

const exposes = require('zigbee-herdsman-converters/lib/exposes');
const {Zcl} = require('zigbee-herdsman');

const e = exposes.presets;
const ea = exposes.access;

const manuSinope = {
    manufacturerCode: 0x119c,
};


/*
 * ==========================================================================
 * HELPERS
 * ==========================================================================
 */

function getCached(endpoint, cluster, attribute) {
    try {
        return endpoint.getClusterAttributeValue(cluster, attribute);
    } catch {
        return undefined;
    }
}


/*
 * Electrical measurements for the Ouellet OTH3600-GA-ZB.
 *
 * Observed scaling:
 *
 *     rmsVoltage = volts
 *     rmsCurrent / 100 = amperes
 *
 * Power:
 *
 *     P = V × I
 *
 * When PI heating demand is 0%, current and power are forced to zero.
 */
function calculateElectrical(endpoint, newValues = {}) {
    const result = {};

    const voltage =
        newValues.voltage !== undefined
            ? Number(newValues.voltage)
            : Number(
                getCached(
                    endpoint,
                    'haElectricalMeasurement',
                    'rmsVoltage',
                ),
            );

    const rawCurrent =
        newValues.rawCurrent !== undefined
            ? Number(newValues.rawCurrent)
            : Number(
                getCached(
                    endpoint,
                    'haElectricalMeasurement',
                    'rmsCurrent',
                ),
            );

    const demand =
        newValues.demand !== undefined
            ? Number(newValues.demand)
            : Number(
                getCached(
                    endpoint,
                    'hvacThermostat',
                    'pIHeatingDemand',
                ),
            );


    /*
     * Voltage
     */
    if (
        Number.isFinite(voltage) &&
        voltage > 0
    ) {
        result.voltage =
            Math.round(voltage * 10) / 10;
    }


    /*
     * PI heating demand
     */
    if (
        Number.isFinite(demand) &&
        demand >= 0 &&
        demand <= 100
    ) {
        result.pi_heating_demand =
            Math.round(demand);

        result.running_state =
            demand >= 10
                ? 'heat'
                : 'idle';
    }


    /*
     * Current
     *
     * OTH3600:
     *
     *     rmsCurrent / 100
     */
    let current;

    if (
        Number.isFinite(rawCurrent) &&
        rawCurrent >= 0
    ) {
        current =
            rawCurrent / 100;


        if (
            Number.isFinite(demand) &&
            demand === 0
        ) {
            current = 0;
        }


        result.current =
            Math.round(current * 100) / 100;
    }


    /*
     * Power
     *
     * Electric floor heating is essentially resistive:
     *
     *     P = V × I
     */
    if (
        Number.isFinite(voltage) &&
        voltage > 0 &&
        Number.isFinite(current)
    ) {
        let power =
            voltage * current;


        if (
            Number.isFinite(demand) &&
            demand === 0
        ) {
            power = 0;
        }


        result.power =
            Math.round(power);
    }


    return result;
}


/*
 * ==========================================================================
 * FROM ZIGBEE
 * ==========================================================================
 */

const fzLocal = {

    /*
     * ----------------------------------------------------------------------
     * Sinopé proprietary cluster
     * ----------------------------------------------------------------------
     */
    sinopeData: {

        cluster: 'manuSpecificSinope',

        type: [
            'attributeReport',
            'readResponse',
        ],

        convert: (
            model,
            msg,
            publish,
            options,
            meta,
        ) => {
            const result = {};


            /*
             * Outdoor temperature
             */
            if (
                msg.data.outdoorTempToDisplay !==
                undefined
            ) {
                result.thermostat_outdoor_temperature =
                    msg.data.outdoorTempToDisplay /
                    100;
            }


            /*
             * Outdoor temperature timeout
             */
            if (
                msg.data.outdoorTempToDisplayTimeout !==
                undefined
            ) {
                result.outdoor_temperature_timeout =
                    msg.data.outdoorTempToDisplayTimeout;
            }


            /*
             * Secondary display mode
             */
            if (
                msg.data.secondScreenBehavior !==
                undefined
            ) {
                const lookup = {
                    0: 'auto',
                    1: 'setpoint',
                    2: 'outdoor temp',
                };

                result.second_display_mode =
                    lookup[
                        msg.data.secondScreenBehavior
                    ];
            }


            return result;
        },
    },


    /*
     * ----------------------------------------------------------------------
     * Electrical measurements
     * ----------------------------------------------------------------------
     */
    electricalMeasurement: {

        cluster: 'haElectricalMeasurement',

        type: [
            'attributeReport',
            'readResponse',
        ],

        convert: (
            model,
            msg,
            publish,
            options,
            meta,
        ) => {
            const values = {};


            if (
                msg.data.rmsVoltage !==
                undefined
            ) {
                values.voltage =
                    msg.data.rmsVoltage;
            }


            if (
                msg.data.rmsCurrent !==
                undefined
            ) {
                values.rawCurrent =
                    msg.data.rmsCurrent;
            }


            return calculateElectrical(
                msg.endpoint,
                values,
            );
        },
    },


    /*
     * ----------------------------------------------------------------------
     * PI heating demand
     * ----------------------------------------------------------------------
     */
    heatingDemand: {

        cluster: 'hvacThermostat',

        type: [
            'attributeReport',
            'readResponse',
        ],

        convert: (
            model,
            msg,
            publish,
            options,
            meta,
        ) => {

            if (
                msg.data.pIHeatingDemand ===
                undefined
            ) {
                return {};
            }


            return calculateElectrical(
                msg.endpoint,
                {
                    demand:
                        Number(
                            msg.data.pIHeatingDemand
                        ),
                },
            );
        },
    },


    /*
     * ----------------------------------------------------------------------
     * Energy
     * ----------------------------------------------------------------------
     *
     * seMetering.currentSummDelivered contains cumulative consumed energy.
     *
     * Zigbee formula:
     *
     *     Energy =
     *         currentSummDelivered × multiplier / divisor
     *
     * If multiplier/divisor are not implemented by the OTH3600,
     * the raw currentSummDelivered value is used.
     */
    metering: {

        cluster: 'seMetering',

        type: [
            'attributeReport',
            'readResponse',
        ],

        convert: (
            model,
            msg,
            publish,
            options,
            meta,
        ) => {
            const result = {};


            if (
                msg.data.currentSummDelivered !==
                undefined
            ) {
                const rawEnergy =
                    Number(
                        msg.data.currentSummDelivered
                    );


                const multiplier =
                    Number(
                        getCached(
                            msg.endpoint,
                            'seMetering',
                            'multiplier',
                        ),
                    );


                const divisor =
                    Number(
                        getCached(
                            msg.endpoint,
                            'seMetering',
                            'divisor',
                        ),
                    );


                let factor = 1;


                if (
                    Number.isFinite(multiplier) &&
                    multiplier > 0 &&
                    Number.isFinite(divisor) &&
                    divisor > 0
                ) {
                    factor =
                        multiplier / divisor;
                }


                if (
                    Number.isFinite(rawEnergy)
                ) {
                    result.energy =
                        Math.round(
                            rawEnergy *
                            factor *
                            1000
                        ) / 1000;
                }
            }


            return result;
        },
    },
};


/*
 * ==========================================================================
 * TO ZIGBEE
 * ==========================================================================
 */

const tzLocal = {

    /*
     * ----------------------------------------------------------------------
     * Outdoor temperature
     * ----------------------------------------------------------------------
     */
    thermostatOutdoorTemperature: {

        key: [
            'thermostat_outdoor_temperature',
        ],

        convertSet: async (
            entity,
            key,
            value,
            meta,
        ) => {
            const temperature =
                Number(value);


            if (
                !Number.isFinite(temperature) ||
                temperature < -99.5 ||
                temperature > 99.5
            ) {
                throw new Error(
                    'Outdoor temperature must be between -99.5 and 99.5 °C'
                );
            }


            await entity.write(
                'manuSpecificSinope',
                {
                    outdoorTempToDisplay:
                        Math.round(
                            temperature * 100
                        ),
                },
                manuSinope,
            );


            return {
                state: {
                    thermostat_outdoor_temperature:
                        temperature,
                },
            };
        },


        convertGet: async (
            entity,
            key,
            meta,
        ) => {
            await entity.read(
                'manuSpecificSinope',
                [
                    'outdoorTempToDisplay',
                ],
                manuSinope,
            );
        },
    },


    /*
     * ----------------------------------------------------------------------
     * Outdoor temperature timeout
     * ----------------------------------------------------------------------
     */
    outdoorTemperatureTimeout: {

        key: [
            'outdoor_temperature_timeout',
        ],

        convertSet: async (
            entity,
            key,
            value,
            meta,
        ) => {
            const timeout =
                Number(value);


            if (
                !Number.isFinite(timeout) ||
                timeout < 30 ||
                timeout > 64800
            ) {
                throw new Error(
                    'Outdoor temperature timeout must be between 30 and 64800 seconds'
                );
            }


            await entity.write(
                'manuSpecificSinope',
                {
                    outdoorTempToDisplayTimeout:
                        Math.round(timeout),
                },
                manuSinope,
            );


            return {
                state: {
                    outdoor_temperature_timeout:
                        timeout,
                },
            };
        },


        convertGet: async (
            entity,
            key,
            meta,
        ) => {
            await entity.read(
                'manuSpecificSinope',
                [
                    'outdoorTempToDisplayTimeout',
                ],
                manuSinope,
            );
        },
    },


    /*
     * ----------------------------------------------------------------------
     * Secondary display mode
     * ----------------------------------------------------------------------
     */
    secondDisplayMode: {

        key: [
            'second_display_mode',
        ],

        convertSet: async (
            entity,
            key,
            value,
            meta,
        ) => {
            const lookup = {
                auto: 0,
                setpoint: 1,
                'outdoor temp': 2,
            };


            if (
                lookup[value] === undefined
            ) {
                throw new Error(
                    'second_display_mode must be auto, setpoint or outdoor temp'
                );
            }


            await entity.write(
                'manuSpecificSinope',
                {
                    secondScreenBehavior:
                        lookup[value],
                },
                manuSinope,
            );


            return {
                state: {
                    second_display_mode:
                        value,
                },
            };
        },


        convertGet: async (
            entity,
            key,
            meta,
        ) => {
            await entity.read(
                'manuSpecificSinope',
                [
                    'secondScreenBehavior',
                ],
                manuSinope,
            );
        },
    },


    /*
     * ----------------------------------------------------------------------
     * Electrical / Energy refresh
     * ----------------------------------------------------------------------
     */
    electricalMeasurements: {

        key: [
            'voltage',
            'current',
            'power',
            'energy',
            'pi_heating_demand',
            'running_state',
        ],

        convertGet: async (
            entity,
            key,
            meta,
        ) => {

            /*
             * Voltage + current
             */
            try {
                await entity.read(
                    'haElectricalMeasurement',
                    [
                        'rmsVoltage',
                        'rmsCurrent',
                    ],
                );
            } catch {
                // Ignore unsupported read
            }


            /*
             * PI heating demand
             */
            try {
                await entity.read(
                    'hvacThermostat',
                    [
                        'pIHeatingDemand',
                    ],
                );
            } catch {
                // Ignore unsupported read
            }


            /*
             * Metering multiplier / divisor.
             *
             * Read separately because the OTH3600 may not
             * implement them.
             */
            try {
                await entity.read(
                    'seMetering',
                    [
                        'multiplier',
                        'divisor',
                    ],
                );
            } catch {
                // Raw energy value will be used.
            }


            /*
             * Cumulative consumed energy.
             */
            try {
                await entity.read(
                    'seMetering',
                    [
                        'currentSummDelivered',
                    ],
                );
            } catch {
                // Ignore unsupported read
            }
        },
    },
};


/*
 * ==========================================================================
 * DEVICE DEFINITION
 * ==========================================================================
 */

const definition = {

    zigbeeModel: [
        'OTH3600-GA-ZB',
    ],

    model:
        'OTH3600-GA-ZB',

    vendor:
        'Ouellet',

    description:
        'Ouellet Zigbee floor heating thermostat',


    /*
     * Sinopé/Ouellet PI heating demand is already 0..100.
     */
    meta: {
        thermostat: {
            dontMapPIHeati