text: const BaseAccessory = require('./BaseAccessory');
  
  class SimpleHeaterAccessory extends BaseAccessory {
      static getCategory(Categories) {
          return Categories.AIR_HEATER;
      }
  
      constructor(...props) {
          super(...props);
      }
  
      _registerPlatformAccessory() {
          const {Service} = this.hap;
  
          this.accessory.addService(Service.HeaterCooler, this.device.context.name);
  
          super._registerPlatformAccessory();
      }
  
      _registerCharacteristics(dps) {
          const {Service, Characteristic} = this.hap;
          const service = this.accessory.getService(Service.HeaterCooler);
          this._checkServiceName(service, this.device.context.name);
  
          this.dpActive = this._getCustomDP(this.device.context.dpActive) || '1';
          this.dpDesiredTemperature = this._getCustomDP(this.device.context.dpDesiredTemperature) || '2';
          this.dpCurrentTemperature = this._getCustomDP(this.device.context.dpCurrentTemperature) || '3';
          this.temperatureDivisor = parseInt(this.device.context.temperatureDivisor) || 1;
  
          const characteristicActive = service.getCharacteristic(Characteristic.Active)
              .updateValue(this._getActive(dps[this.dpActive]))
              .on('get', this.getActive.bind(this))
              .on('set', this.setActive.bind(this));
  
          service.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
              .updateValue(this._getCurrentHeaterCoolerState(dps))
              .on('get', this.getCurrentHeaterCoolerState.bind(this));
  
          service.getCharacteristic(Characteristic.TargetHeaterCoolerState)
              .setProps({
                  minValue: 1,
                  maxValue: 1,
                  validValues: [Characteristic.TargetHeaterCoolerState.HEAT]
              })
              .updateValue(this._getTargetHeaterCoolerState())
              .on('get', this.getTargetHeaterCoolerState.bind(this))
              .on('set', this.setTargetHeaterCoolerState.bind(this));
  
          const characteristicCurrentTemperature = service.getCharacteristic(Characteristic.CurrentTemperature)
              .updateValue(this._getDividedState(dps[this.dpCurrentTemperature], this.temperatureDivisor))
              .on('get', this.getDividedState.bind(this, this.dpCurrentTemperature, this.temperatureDivisor));
  
  
          const characteristicHeatingThresholdTemperature = service.getCharacteristic(Characteristic.HeatingThresholdTemperature)
              .setProps({
                  minValue: this.device.context.minTemperature || 15,
                  maxValue: this.device.context.maxTemperature || 35,
                  minStep: this.device.context.minTemperatureSteps || 1
              })
              .updateValue(this._getDividedState(dps[this.dpDesiredTemperature], this.temperatureDivisor))
              .on('get', this.getDividedState.bind(this, this.dpDesiredTemperature, this.temperatureDivisor))
              .on('set', this.setTargetThresholdTemperature.bind(this));
  
          this.characteristicHeatingThresholdTemperature = characteristicHeatingThresholdTemperature;
  
          this.device.on('change', (changes, state) => {
              if (changes.hasOwnProperty(this.dpActive)) {
                  const newActive = this._getActive(changes[this.dpActive]);
                  if (characteristicActive.value !== newActive) {
                      characteristicActive.updateValue(newActive);
                  }
              }
  
              if (changes.hasOwnProperty(this.dpDesiredTemperature)) {
                  if (characteristicHeatingThresholdTemperature.value !== changes[this.dpDesiredTemperature])
                      characteristicHeatingThresholdTemperature.updateValue(changes[this.dpDesiredTemperature]);
              }
  
              if (changes.hasOwnProperty(this.dpCurrentTemperature) && characteristicCurrentTemperature.value !== changes[this.dpCurrentTemperature]) characteristicCurrentTemperature.updateValue(changes[this.dpCurrentTemperature]);
  
              console.log('[TuyaAccessory] SimpleHeater changed: ' + JSON.stringify(state));
          });
      }
  
      getActive(callback) {
          this.getState(this.dpActive, (err, dp) => {
              if (err) return callback(err);
  
              callback(null, this._getActive(dp));
          });
      }
  
      _getActive(dp) {
          const {Characteristic} = this.hap;
  
          return dp ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE;
      }
  
      setActive(value, callback) {
          const {Characteristic} = this.hap;
  
          switch (value) {
              case Characteristic.Active.ACTIVE:
                  return this.setState(this.dpActive, true, callback);
  
              case Characteristic.Active.INACTIVE:
                  return this.setState(this.dpActive, false, callback);
          }
  
          callback();
      }
  
      getCurrentHeaterCoolerState(callback) {
          this.getState([this.dpActive], (err, dps) => {
              if (err) return callback(err);
  
              callback(null, this._getCurrentHeaterCoolerState(dps));
          });
      }
  
      _getCurrentHeaterCoolerState(dps) {
          const {Characteristic} = this.hap;
          return dps[this.dpActive] ? Characteristic.CurrentHeaterCoolerState.HEATING : Characteristic.CurrentHeaterCoolerState.INACTIVE;
      }
  
      getTargetHeaterCoolerState(callback) {
          callback(null, this._getTargetHeaterCoolerState());
      }
  
      _getTargetHeaterCoolerState() {
          const {Characteristic} = this.hap;
          return Characteristic.TargetHeaterCoolerState.HEAT;
      }
  
      setTargetHeaterCoolerState(value, callback) {
          this.setState(this.dpActive, true, callback);
      }
  
      setTargetThresholdTemperature(value, callback) {
          this.setState(this.dpDesiredTemperature, value * this.temperatureDivisor, err => {
              if (err) return callback(err);
  
              if (this.characteristicHeatingThresholdTemperature) {
                  this.characteristicHeatingThresholdTemperature.updateValue(value);
              }
  
              callback();
          });
      }
  }
  
  module.exports = SimpleHeaterAccessory;