import org.openhab.model.script.actions.Timer

var String HeatingPreviousMode = "OFF"
var String CoolingPreviousMode = "OFF"
var String FanPreviousMode = "OFF"

rule "Initialisation"
when
	System started
then
	MainSwitch.sendCommand("OFF")
	HeatingMode.sendCommand("OFF")
	CoolingMode.sendCommand("OFF")
	FanMode.sendCommand("OFF")
	//CELSIUS if(TempMinSetpoint.state == NULL) postUpdate(TempMinSetpoint, 16)
	//CELSIUS if(TempMinSetpoint.state > 40) postUpdate(TempMinSetpoint, 16)
	/**FAHRENHEIT*/ if(TempMinSetpoint.state == NULL) postUpdate(TempMinSetpoint, 68)
	/**FAHRENHEIT*/ if(TempMinSetpoint.state < 32) postUpdate(TempMinSetpoint, 68)

	//CELSIUS if(TempMaxSetpoint.state == NULL) postUpdate(TempMaxSetpoint, 18)
	//CELSIUS if(TempMaxSetpoint.state > 40) postUpdate(TempMaxSetpoint, 18)
	/**FAHRENHEIT*/ if(TempMaxSetpoint.state == NULL) postUpdate(TempMaxSetpoint, 72)
	/**FAHRENHEIT*/ if(TempMaxSetpoint.state < 32) postUpdate(TempMaxSetpoint, 72)

	TempMinSetpointChart.sendCommand(0);
	TempMaxSetpointChart.sendCommand(0);
	PreviousTempReading.sendCommand(0);
	PreviousHumiReading.sendCommand(0);
	chart_period.sendCommand(0);
end

rule "convertproxy"
when
	Item MyTemp changed or
	Item MyHumi changed
then
	MyTempProxy.postUpdate(Double::parseDouble(MyTemp.state.toString))
	MyHumiProxy.postUpdate(Double::parseDouble(MyHumi.state.toString))
	//CELSIUS if ((Double::parseDouble(MyTemp.state.toString) < (Double::parseDouble(PreviousTempReading.state.toString)) - 0.2) || (Double::parseDouble(MyTemp.state.toString) > (Double::parseDouble(PreviousTempReading.state.toString)) + 0.2)) {
		PreviousTempReading.postUpdate(Double::parseDouble(MyTemp.state.toString))
	//CELSIUS }
	if((Double::parseDouble(MyHumi.state.toString) < (Double::parseDouble(PreviousHumiReading.state.toString)) - 0.4) || (Double::parseDouble(MyHumi.state.toString) > (Double::parseDouble(PreviousHumiReading.state.toString)) + 0.4)) {
		PreviousHumiReading.postUpdate(Double::parseDouble(MyHumi.state.toString))
	}
end

rule "SetTempMinSetpointInc"
when
	Item IncTargetTempMin changed
then
  if (TempMinSetpoint.state < TempMaxSetpoint.state) {
    var Number minSetpoint = TempMinSetpoint.state as DecimalType
    //CELSIUS minSetpoint = minSetpoint + 0.5
    /**FAHRENHEIT*/ minSetpoint = minSetpoint + 1
    TempMinSetpoint.sendCommand(minSetpoint) //postUpdate(TempMinSetpoint, minSetpoint)
    TempMinSetpointChart.sendCommand(minSetpoint)
  }
end

rule "SetTempMinSetpointDec"
when
	Item DecTargetTempMin changed
then
	var Number minSetpoint = TempMinSetpoint.state as DecimalType
	//CELSIUS minSetpoint = minSetpoint - 0.5
	/**FAHRENHEIT*/ minSetpoint = minSetpoint - 1
	TempMinSetpoint.sendCommand(minSetpoint) //postUpdate(TempMinSetpoint, minSetpoint)
	TempMinSetpointChart.sendCommand(minSetpoint)
end

rule "SetTempMaxSetpointInc"
when
	Item IncTargetTempMax changed
then
	var Number maxSetpoint = TempMaxSetpoint.state as DecimalType
	//CELSIUS maxSetpoint = maxSetpoint + 0.5
	/**FAHRENHEIT*/ maxSetpoint = maxSetpoint + 1
	TempMaxSetpoint.sendCommand(maxSetpoint) //postUpdate(TempMaxSetpoint, maxSetpoint)
	TempMaxSetpointChart.sendCommand(maxSetpoint)
end

rule "SetTempMaxSetpointDec"
when
	Item DecTargetTempMax changed
then
  if (TempMinSetpoint.state < TempMaxSetpoint.state) {
    var Number maxSetpoint = TempMaxSetpoint.state as DecimalType
    //CELSIUS maxSetpoint = maxSetpoint - 0.5
    /**FAHRENHEIT*/ maxSetpoint = maxSetpoint - 1
    TempMaxSetpoint.sendCommand(maxSetpoint) //postUpdate(TempMaxSetpoint, maxSetpoint)
    TempMaxSetpointChart.sendCommand(maxSetpoint)
  }
end

rule "BlockSetpointOverlapUp"
when
	Item TempMinSetpoint changed
then
  if (TempMinSetpoint.state > TempMaxSetpoint.state) {
	  TempMaxSetpoint.sendCommand(TempMinSetpoint.state as DecimalType)
	}
end

rule "BlockSetpointOverlapDown"
when
	Item TempMaxSetpoint changed
then
  if (TempMinSetpoint.state > TempMaxSetpoint.state) {
	  TempMinSetpoint.sendCommand(TempMaxSetpoint.state as DecimalType)
	}
end

rule "checkcurrtemp"
when
	Item TempMinSetpoint changed or
	Item TempMaxSetpoint changed or
	Item PreviousTempReading changed
then
	if(MyTempProxy.state > TempMinSetpoint.state) {
		HeatingPin.sendCommand(OFF)
		TempMinSetpointChart.sendCommand(0)
	}
	else if((MyTempProxy.state < TempMinSetpoint.state) && (HeatingMode.state=="ON")) {
		HeatingPin.sendCommand(ON)
		FanPin.sendCommand(ON)
		TempMinSetpointChart.sendCommand(TempMinSetpoint.state as DecimalType)
	}
	if(MyTempProxy.state < TempMaxSetpoint.state) {
		CoolingPin.sendCommand(OFF)
		TempMaxSetpointChart.sendCommand(0)
	}
	else if((MyTempProxy.state > TempMaxSetpoint.state) && (CoolingMode.state=="ON")) {
		CoolingPin.sendCommand(ON)
		FanPin.sendCommand(ON)
		TempMaxSetpointChart.sendCommand(TempMaxSetpoint.state as DecimalType)
	}
		if((MyTempProxy.state > TempMinSetpoint.state) && (MyTempProxy.state < TempMaxSetpoint.state)) {
		FanPin.sendCommand(OFF)
	}
end

/*
rule "checkcurrhumi"
when
	Item HumiSetpoint changed or
	Item PreviousHumiReading changed
then
	if(MyHumiProxy.state < HumiSetpoint.state){
		HumidityPin18.sendCommand(OFF)
		HumiSetpointChart.sendCommand(0)
	}
	else if((MyHumiProxy.state > HumiSetpoint.state) && ((HumiMode.state=="ON") || (HumiMode.state=="Boost"))) {
	HumidityPin18.sendCommand(ON)
	HumiSetpointChart.sendCommand(HumiSetpoint.state as DecimalType)
	}
end
*/

rule "Heating Mode"
when
	Item HeatingMode changed
then
	switch(HeatingMode.state) {
		case "ON": {
			if(MyTempProxy.state < TempMinSetpoint.state) {
				HeatingPin.sendCommand(ON)
				FanPin.sendCommand(ON)
				TempMinSetpointChart.sendCommand(TempMinSetpoint.state as DecimalType)
			}
			MainSwitch.sendCommand("ON")
			CoolingMode.sendCommand("OFF")
			HeatingPreviousMode="ON"
		}
		case "OFF": {
			HeatingPin.sendCommand(OFF)
			TempMinSetpointChart.sendCommand(0)
			HeatingPreviousMode="OFF"
		}
		case "Schedule": {
			HeatingPin.sendCommand(OFF)
			TempMinSetpointChart.sendCommand(0)
			MainSwitch.sendCommand("ON")
			HeatingPreviousMode="Schedule"
		}
	}
end

rule "Cooling Mode"
when
	Item CoolingMode changed
then
	switch(CoolingMode.state) {
		case "ON": {
			if(MyTempProxy.state > TempMaxSetpoint.state) {
				CoolingPin.sendCommand(ON)
				FanPin.sendCommand(ON)
				TempMaxSetpointChart.sendCommand(TempMaxSetpoint.state as DecimalType)
			}
			MainSwitch.sendCommand("ON")
			HeatingMode.sendCommand("OFF")
			CoolingPreviousMode="ON"
		}
		case "OFF": {
			CoolingPin.sendCommand(OFF)
			TempMaxSetpointChart.sendCommand(0)
			CoolingPreviousMode="OFF"
		}
		case "Schedule": {
			CoolingPin.sendCommand(OFF)
			TempMaxSetpointChart.sendCommand(0)
			MainSwitch.sendCommand("ON")
			CoolingPreviousMode="Schedule"
		}
	}
end


rule "MainSwitch"
when
    Item MainSwitch changed
then
    switch(MainSwitch.state) {
      case ON:{
        // Do nothing
      }
      case OFF:{
        if (HeatingMode.state == "ON") {
          HeatingPreviousMode = "ON"
          HeatingMode.sendCommand("OFF")
        } else if (HeatingMode.state == "Schedule") {
          HeatingPreviousMode="Schedule"
          HeatingMode.sendCommand("OFF")
        }
      }
    }
end