import sys
import ast
from insel.insel import Insel
from pathlib import Path
from populate import Populate
from simplified_radiosity_algorithm import SimplifiedRadiosityAlgorithm
from imports.weather_factory import WeatherFactory
from insel.templates.thermal_demand_dynamic_simulation import ThermalDemandDynamicSimulation as Templates
from helpers.simulation_parameters import SimulationParameters as Sp
import helpers.constants as cte
from imports.geometry_factory import GeometryFactory
from imports.geometry_feeders.helpers.geometry_helper import GeometryHelper

name_gml = 'one_building_in_kelowna.gml'
function_format = 'hft'
construction_format = 'nrcan'
usage_format = 'hft'
schedules_format = 'comnet'
climate_reference_city = 'Summerland'
weather_file_name = 'CAN_BC_Summerland.717680_CWEC.epw'

example_path = Path(__file__).parent
full_path_gml = (example_path / 'tests' / 'tests_data' / name_gml).resolve()
outputs_path = (example_path / 'tests' / 'tests_outputs').resolve()
tmp_path = (example_path / 'tests' / 'tmp').resolve()
weather_path = (Path(__file__).parent.parent / 'libs' / 'data' / 'weather').resolve()
keep_files = True

# Initialize the city model and add thermal- and usage-related parameters
# todo: add several steps:
#  - simplification of the data model (for all work-flows)
#  - internal zoning of buildings (for dynamic simulation only)
city = GeometryFactory('citygml', full_path_gml).city
for building in city.buildings:
  if function_format == 'hft':
    building.function = GeometryHelper.hft_to_function[building.function]
  elif function_format == 'pluto':
    building.function = GeometryHelper.pluto_to_function[building.function]

populated_city = Populate(city).populated_city(construction_format, usage_format, schedules_format)

weather_format = 'epw'
city.climate_reference_city = climate_reference_city
city.climate_file = (tmp_path / f'{climate_reference_city}.cli').resolve()
WeatherFactory(weather_format, populated_city, base_path=weather_path, file_name=weather_file_name).enrich()
for building in populated_city.buildings:
  if cte.HOUR not in building.external_temperature:
    print('No external temperature found')
    sys.exit()

max_buildings_handled_by_sra = 500
for building in city.buildings:
  for surface in building.surfaces:
    surface.swr = 0.2
path = (example_path / 'tests').resolve()
sra = SimplifiedRadiosityAlgorithm(city, path, weather_file_name)
total_number_of_buildings = len(city.buildings)
if total_number_of_buildings > max_buildings_handled_by_sra:
  radius = 80
  for building in city.buildings:
    new_city = city.region(building.centroid, radius)
    sra_new = SimplifiedRadiosityAlgorithm(new_city, path, weather_file_name)
    sra_new.call_sra(weather_format, keep_files=keep_files)
    sra_new.set_irradiance_surfaces(populated_city, building_name=building.name)
else:
  sra.call_sra(weather_format, keep_files=keep_files)
  sra.set_irradiance_surfaces(populated_city, mode=1)
  print(city.buildings[0].surfaces[1].global_irradiance)
quit()

# Demand calculation (one model per building)
for city_object in city.city_objects:
  full_path_out = (outputs_path / city_object.name).resolve()
  (example_path / 'third_party_files/sra').resolve()
  full_path_wea = (example_path / 'third_party_files/insel' / (city_object.name + '.weather')).resolve()
  full_path_ig = (example_path / 'third_party_files/insel' / (city_object.name + '.ig')).resolve()

  insel_file_name = city_object.name + '.insel'
  try:
    content = Templates.generate_thermal_dynamic_template(city_object, full_path_out, full_path_wea, full_path_ig, Sp)
    insel = Insel(example_path, insel_file_name, content, mode=2, keep_files=keep_files).results
  except:
    print(sys.exc_info()[1])
    print('Building ' + city_object.name + ' could not be processed')
    continue