from components.plant.pot import Pot
from components.pid.temp_controller_base import TempControllerBase, States


class TempController(TempControllerBase):
	def __init__(self, dt):
		TempControllerBase.__init__(self, dt)
		self.dt = dt
		# None until the first process() tick - rather than hardcoding a
		# starting point (e.g. 20), which would make that very first
		# tick's heatrate come out as a bogus spike whenever the real
		# starting temperature isn't actually 20 (see
		# components/sud_forecast.py's SudForecastEstimator, which builds
		# a fresh TempController on every call - unlike the real one,
		# which only ever goes through this exactly once, it has no
		# earlier ticks to have already settled past that spike by).
		self.last_theta_ist = None
		self.heatrate_ist = 0

		# Fast model: same plant model but with zero transport delay, used
		# to predict the current temperature without the dead time.
		self.model = Pot(dt)
		# Delayed model: keeps the plant's assumed transport delay, so it
		# can be compared like-for-like against the real (delayed) measurement.
		self.model_delay = Pot(dt)

		self.theta_ist_plant = 0
		self.theta_ist_model = 0
		self.theta_ist_model_delay = 0

	def set_model_plant_params(self, model_params):
		self.model.set_plant_params({**model_params, 'Td': 0})
		self.model_delay.set_plant_params(model_params)

	def set_model_power(self, power):
		self.model.set_power(power)
		self.model_delay.set_power(power)

	def set_ambient_temperature(self, theta_amb):
		self.model.set_ambient_temperature(theta_amb)
		self.model_delay.set_ambient_temperature(theta_amb)

	def is_configured(self):
		return super().is_configured() and self.model.is_configured() and self.model_delay.is_configured()

	def on_state_entered(self, state):
		if state in (States.HEAT, States.COOL):
			self.model.initial(self.theta_ist)
			self.model_delay.initial(self.theta_ist)

	def post_pid(self):
		self.model.process()
		self.model_delay.process()

	def process(self):
		self._require_params()
		if not (self.model.is_configured() and self.model_delay.is_configured()):
			raise RuntimeError(
				"{}.process(): model plant params and/or ambient temperature not set - "
				"call set_model_plant_params() and set_ambient_temperature() first".format(type(self).__name__))

		self.theta_ist_plant = self.theta_ist_set
		self.theta_ist_model = self.model.get_temperature()
		self.theta_ist_model_delay = self.model_delay.get_temperature()

		# Smith predictor: use the fast model's prediction, corrected by the
		# mismatch between the real (delayed) plant and the delayed model,
		# so the dead time drops out of the feedback path.
		self.theta_ist = self.theta_ist_model + (self.theta_ist_plant - self.theta_ist_model_delay)

		heatrate = 0 if self.last_theta_ist is None else (self.theta_ist - self.last_theta_ist)/self.dt*60

		alpha = 0.1
		self.heatrate_ist = (1-alpha) * self.heatrate_ist + alpha*heatrate
		self.last_theta_ist = self.theta_ist

		# Compensate for max heat rate to reduce overshoot
		hold_scale = 1.0/self.heatrate_soll_set if self.heatrate_soll_set > 0 else 1.0

		self.heatrate_soll = self.heatrate_soll_set * self.pid_hold.get_y()
		theta_err = self.theta_soll_set - self.theta_ist
		heatrate_err = self.heatrate_soll - self.heatrate_ist

		diff = self.theta_soll_set - self.theta_ist
		self.process_fsm(diff)
		self.process_pid(theta_err, heatrate_err, hold_scale)