"""
ThermalBoundary module
SPDX - License - Identifier: LGPL - 3.0 - or -later
Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
Contributors Pilar Monsalvete pilar_monsalvete@yahoo.es
"""
from typing import List
from city_model_structure.attributes.layer import Layer
from city_model_structure.attributes.thermal_opening import ThermalOpening
from city_model_structure.attributes.thermal_zone import ThermalZone
from city_model_structure.attributes.surface import Surface


class ThermalBoundary:
  """
  ThermalBoundary class
  """
  def __init__(self, surface, delimits, hi, he):
    self._surface = surface
    self._delimits = delimits
    # ToDo: up to at least LOD2 will be just one thermal opening per Thermal boundary, review for LOD3 and LOD4
    self._thermal_openings = [ThermalOpening(hi, he)]
    self._layers = None
    self._outside_solar_absorptance = None
    self._outside_thermal_absorptance = None
    self._outside_visible_absorptance = None
    self._window_ratio = None
    self._u_value = None
    self._window_area = None
    self._shortwave_reflectance = None
    self._construction_name = None
    self._hi = hi
    self._he = he

  @property
  def surface(self) -> Surface:
    """
    Get the surface that belongs to the thermal boundary
    :return: Surface
    """
    return self._surface

  @property
  def delimits(self) -> List[ThermalZone]:
    """
    Get the thermal zones delimited by the thermal boundary
    :return: [ThermalZone]
    """
    return self._delimits

  @property
  def azimuth(self):
    """
    Thermal boundary azimuth in radians
    :return: float
    """
    return self._surface.azimuth

  @property
  def inclination(self):
    """
    Thermal boundary inclination in radians
    :return: float
    """
    return self._surface.inclination

  @property
  def area(self):
    """
    Thermal boundary area in square meters
    :return: float
    """
    return self._surface.area

  @property
  def area_above_ground(self):
    """
    Thermal boundary area above ground in square meters
    :return: float
    """
    return self._surface.area_above_ground

  @property
  def area_below_ground(self):
    """
    Thermal boundary area below ground in square meters
    :return: float
    """
    return self._surface.area_below_ground

  @property
  def outside_solar_absorptance(self):
    """
    Get thermal boundary outside solar absorptance
    :return: float
    """
    return self._outside_solar_absorptance

  @outside_solar_absorptance.setter
  def outside_solar_absorptance(self, value):
    """
    Set thermal boundary outside solar absorptance
    :param value: float
    :return: None
    """
    self._outside_solar_absorptance = value
    self._shortwave_reflectance = 1.0 - float(value)

  @property
  def outside_thermal_absorptance(self):
    """
    Get thermal boundary outside thermal absorptance
    :return: float
    """
    return self._outside_thermal_absorptance

  @outside_thermal_absorptance.setter
  def outside_thermal_absorptance(self, value):
    """
    Set thermal boundary outside thermal absorptance
    :param value: float
    :return: None
    """
    self._outside_thermal_absorptance = value

  @property
  def outside_visible_absorptance(self):
    """
    Get thermal boundary outside visible absorptance
    :return: float
    """
    return self._outside_visible_absorptance

  @outside_visible_absorptance.setter
  def outside_visible_absorptance(self, value):
    """
    Set thermal boundary outside visible absorptance
    :param value: float
    :return: None
    """
    self._outside_visible_absorptance = value

  @property
  def thermal_openings(self) -> List[ThermalOpening]:
    """
    Get thermal boundary thermal openings
    :return: [ThermalOpening]
    """
    return self._thermal_openings

  @thermal_openings.setter
  def thermal_openings(self, value):
    """
    Set thermal boundary thermal openings
    :param value: [ThermalOpening]
    :return: None
    """
    self._thermal_openings = value

  @property
  def construction_name(self):
    """
    Get construction name
    :return:
    """
    return self._construction_name

  @construction_name.setter
  def construction_name(self, value):
    self._construction_name = value

  @property
  def layers(self) -> List[Layer]:
    """
    Get thermal boundary layers
    :return: [Layers]
    """
    return self._layers

  @layers.setter
  def layers(self, value):
    """
    Set thermal boundary layers
    :param value: [Layer]
    :return: None
    """
    self._layers = value

  @property
  def type(self):
    """
    Thermal boundary surface type
    :return: str
    """
    return self._surface.type

  @property
  def window_ratio(self):
    """
    Get thermal boundary window ratio
    :return: float
    """
    return self._window_ratio

  @window_ratio.setter
  def window_ratio(self, value):
    """
    Set thermal boundary window ratio
    :param value: float
    :return: None
    """
    self._window_ratio = value

  @property
  def window_area(self):
    """
    Thermal boundary window area in square meters
    :return: float
    """
    if self._window_area is None:
      try:
        self._window_area = float(self._surface.area) * float(self.window_ratio)
      except TypeError:
        raise Exception('Window ratio is not defined or invalid surface area')
    return self._window_area

  # todo: what if I just want to assign a number??
  @property
  def u_value(self):
    """
    Get thermal boundary U-value in W/m2K
    internal and external convective coefficient in W/m2K values, can be configured at configuration.ini
    :return: float
    """
    if self._u_value is None:
      h_i = self._hi
      h_e = self._he
      r_value = 1.0/h_i + 1.0/h_e
      try:
        for layer in self.layers:
          if layer.material.no_mass:
            r_value += float(layer.material.thermal_resistance)
          else:
            r_value = r_value + float(layer.material.conductivity) / float(layer.thickness)
        self._u_value = 1.0/r_value
      except TypeError:
        raise Exception('Constructions layers are not initialized')
    return self._u_value

  @u_value.setter
  def u_value(self, value):
    """
    Set thermal boundary U-value in W/m2K
    :param value: float
    """
    self._u_value = value

  @property
  def shortwave_reflectance(self):
    """
    Get thermal boundary shortwave reflectance
    :return: float
    """
    return self._shortwave_reflectance

  @shortwave_reflectance.setter
  def shortwave_reflectance(self, value):
    """
    Set thermal boundary shortwave reflectance
    :param value: float
    :return:
    """
    self._shortwave_reflectance = value
    self._outside_solar_absorptance = 1.0 - float(value)