"""
ThermalBoundary module
SPDX - License - Identifier: LGPL - 3.0 - or -later
Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
Contributors Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
"""
from typing import List, TypeVar
from city_model_structure.attributes.layer import Layer
from city_model_structure.attributes.thermal_opening import ThermalOpening
from city_model_structure.attributes.surface import Surface

ThermalZone = TypeVar('ThermalZone')
Polygon = TypeVar('Polygon')


class ThermalBoundary:
  """
  ThermalBoundary class
  """
  def __init__(self, surface, delimits):
    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()]
    self._layers = None
    self._outside_solar_absorptance = None
    self._outside_thermal_absorptance = None
    self._outside_visible_absorptance = None
    self._u_value = None
    self._shortwave_reflectance = None
    self._construction_name = None
    self._hi = None
    self._he = None
    self._window_ratio = None
    self._refurbishment_measure = None
    self._surface_geometry = None

  @property
  def surface(self) -> Surface:
    """
    Get the surface that belongs to the thermal boundary
    :return: Surface
    """
    # todo: in LoD4 this property will be a list of surfaces, not only one
    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.solid_polygon.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

  # 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)

  @property
  def hi(self):
    """
    Get internal convective heat transfer coefficient (W/m2K)
    :return: float
    """
    return self._hi

  @hi.setter
  def hi(self, value):
    """
    Set internal convective heat transfer coefficient (W/m2K)
    :param value: internal convective heat transfer coefficient (W/m2K)
    :return:
    """
    self._hi = value

  @property
  def he(self):
    """
    Get external convective heat transfer coefficient (W/m2K)
    :return: float
    """
    return self._he

  @he.setter
  def he(self, value):
    """
    Set external convective heat transfer coefficient (W/m2K)
    :param value: external convective heat transfer coefficient (W/m2K)
    :return:
    """
    self._he = value

  @property
  def surface_geometry(self) -> Polygon:
    """
    Get the polygon that defines the thermal boundary
    :return: Polygon
    """
    return self._surface_geometry