# *********************************************************************
# *  Copyright (c) 2008-2015, Natural Resources Canada
# *  All rights reserved.
# *
# *  This library is free software; you can redistribute it and/or
# *  modify it under the terms of the GNU Lesser General Public
# *  License as published by the Free Software Foundation; either
# *  version 2.1 of the License, or (at your option) any later version.
# *
# *  This library is distributed in the hope that it will be useful,
# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# *  Lesser General Public License for more details.
# *
# *  You should have received a copy of the GNU Lesser General Public
# *  License along with this library; if not, write to the Free Software
# *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
# **********************************************************************/

require 'json'
require "#{File.dirname(__FILE__)}/btap"


module BTAP
  #Contains data and methods for compliance and archetype work.
  module Compliance
    # Contains NECB relelvant methods and data.
    module NECB2011
      # NECB data tables / arrays.
      module Data
        #Envelope Conductance values for each climat zone / HDD limits.
        module Conductances
          #array of conductances(metric) per climate zone.
          Wall = [0.315, 0.278, 0.247, 0.210, 0.210, 0.183]
          Roof = [0.227, 0.183, 0.183, 0.162, 0.162, 0.142]
          Floor = [0.227, 0.183, 0.183, 0.162, 0.162, 0.142]
          Window = [2.400, 2.200, 2.200, 2.200, 2.200, 1.600]
          Door = [2.400, 2.200, 2.200, 2.200, 2.200, 1.600]
          GroundWall = [0.568, 0.379, 0.284, 0.284, 0.284, 0.210]
          GroundRoof = [0.568, 0.379, 0.284, 0.284, 0.284, 0.210]
          GroundFloor = [0.757, 0.757, 0.757, 0.757, 0.757, 0.379]
        end
      end


      #This method ???.
      #@author phylroy.lopez@nrcan.gc.ca
      #@param hdd [Float]
      #@return [Double] a constant float
      def self.max_fwdr(hdd)
        #NECB 3.2.1.4

        if hdd < 4000
          return 0.40
        elsif hdd >= 4000 and hdd <=7000
          return (2000-0.2 * hdd)/3000
        elsif hdd >7000
          return 0.20
        end
      end


      # This method will set the the envelope (wall, roof, glazings) to  values to
      # the default NECB2011 values based on the heating degree day value (hdd) surface by surface.
      #@author phylroy.lopez@nrcan.gc.ca
      #@param model [OpenStudio::model::Model] A model object
      #@param hdd [Float]
      def self.set_necb_envelope(model, runner=nil)

        BTAP::runner_register("Info", "set_envelope_surfaces_to_necb!", runner)
        if model.weatherFile.empty? or model.weatherFile.get.path.empty? or not File.exists?(model.weatherFile.get.path.get.to_s)

          BTAP::runner_register("Error", "Weather file is not defined. Please ensure the weather file is defined and exists.", runner)
          return false
        end
        hdd = BTAP::Environment::WeatherFile.new(model.weatherFile.get.path.get).hdd18

        #interate Through all surfaces
        model.getSurfaces.sort.each do |surface|
          #set fenestration to wall ratio.
          BTAP::Compliance::NECB2011::set_necb_external_surface_conductance(surface, hdd, false, 1.0)

          #dig into the subsurface and change them as well.
          model.getSubSurfaces.sort.each do |subsurface|
            BTAP::Compliance::NECB2011::set_necb_external_subsurface_conductance(subsurface, hdd)
          end
        end
      end

      # this will create a copy and convert all construction sets to NECB reference conductances.
      #@author phylroy.lopez@nrcan.gc.ca
      #@param model [OpenStudio::model::Model] A model object
      #@param default_surface_construction_set [String]
      #@return [Boolean] returns true if sucessful, false if not
      def self.set_construction_set_to_necb!(model, default_surface_construction_set,
          runner = nil,
          scale_wall = 1.0,
          scale_floor = 1.0,
          scale_roof = 1.0,
          scale_ground_wall = 1.0,
          scale_ground_floor = 1.0,
          scale_ground_roof = 1.0,
          scale_door = 1.0,
          scale_window = 1.0
      )
        BTAP::runner_register("Info", "set_construction_set_to_necb!", runner)
        if model.weatherFile.empty? or model.weatherFile.get.path.empty? or not File.exists?(model.weatherFile.get.path.get.to_s)

          BTAP::runner_register("Error", "Weather file is not defined. Please ensure the weather file is defined and exists.", runner)
          return false
        end
        hdd = BTAP::Environment::WeatherFile.new(model.weatherFile.get.path.get).hdd18

        old_name = default_surface_construction_set.name.get.to_s


        climate_zone_index = get_climate_zone_index(hdd)
        new_name = "#{old_name} at hdd = #{hdd}"

        #convert conductance values to rsi values. (Note: we should really be only using conductances in)
        wall_rsi = 1.0 / (scale_wall * BTAP::Compliance::NECB2011::Data::Conductances::Wall[climate_zone_index])
        floor_rsi = 1.0 / (scale_floor * BTAP::Compliance::NECB2011::Data::Conductances::Floor[climate_zone_index])
        roof_rsi = 1.0 / (scale_roof * BTAP::Compliance::NECB2011::Data::Conductances::Roof[climate_zone_index])
        ground_wall_rsi = 1.0 / (scale_ground_wall * BTAP::Compliance::NECB2011::Data::Conductances::GroundWall[climate_zone_index])
        ground_floor_rsi = 1.0 / (scale_ground_floor * BTAP::Compliance::NECB2011::Data::Conductances::GroundFloor[climate_zone_index])
        ground_roof_rsi = 1.0 / (scale_ground_roof * BTAP::Compliance::NECB2011::Data::Conductances::GroundRoof[climate_zone_index])
        door_rsi = 1.0 / (scale_door * BTAP::Compliance::NECB2011::Data::Conductances::Door[climate_zone_index])
        window_rsi = 1.0 / (scale_window * BTAP::Compliance::NECB2011::Data::Conductances::Window[climate_zone_index])
        BTAP::Resources::Envelope::ConstructionSets::customize_default_surface_construction_set_rsi!(model, new_name, default_surface_construction_set,
                                                                                                     wall_rsi, floor_rsi, roof_rsi,
                                                                                                     ground_wall_rsi, ground_floor_rsi, ground_roof_rsi,
                                                                                                     window_rsi, nil, nil,
                                                                                                     window_rsi, nil, nil,
                                                                                                     door_rsi,
                                                                                                     door_rsi, nil, nil,
                                                                                                     door_rsi,
                                                                                                     window_rsi, nil, nil,
                                                                                                     window_rsi, nil, nil,
                                                                                                     window_rsi, nil, nil
        )
        BTAP::runner_register("Info", "set_construction_set_to_necb! was sucessful.", runner)
        return true
      end

      # This method will convert in place(over write) a construction set to necb conductances.
      #@author phylroy.lopez@nrcan.gc.ca
      #@param model [OpenStudio::model::Model] A model object
      #@param scale_wall [Float]
      #@param scale_floor [Float]
      #@param scale_roof [Float]
      #@param scale_ground_wall [Float]
      #@param scale_ground_floor [Float]
      #@param scale_ground_roof [Float]
      #@param scale_door [Float]
      #@param scale_window [Float]
      def self.set_all_construction_sets_to_necb!(model,
          runner = nil,
          scale_wall = 1.0,
          scale_floor = 1.0,
          scale_roof = 1.0,
          scale_ground_wall = 1.0,
          scale_ground_floor = 1.0,
          scale_ground_roof = 1.0,
          scale_door = 1.0,
          scale_window = 1.0)

        model.getDefaultConstructionSets.sort.each do |set|
          self.set_construction_set_to_necb!(model,
                                             set,
                                             runner,
                                             scale_wall,
                                             scale_floor,
                                             scale_roof,
                                             scale_ground_wall,
                                             scale_ground_floor,
                                             scale_ground_roof,
                                             scale_door,
                                             scale_window)
        end
        #sets all surfaces to use default constructions sets except adiabatic, where it does a hard assignment of the interior wall construction type. 
        model.getPlanarSurfaces.sort.each {|item| item.resetConstruction}
        #if the default construction set is defined..try to assign the interior wall to the adiabatic surfaces
        BTAP::Resources::Envelope::assign_interior_surface_construction_to_adiabatic_surfaces(model, nil)
      end

      #This model gets the climate zone column index from tables 3.2.2.x
      #@author phylroy.lopez@nrcan.gc.ca
      #@param hdd [Float]
      #@return [Fixnum] climate zone 4-8
      def self.get_climate_zone_index(hdd)
        #check for climate zone index from NECB 3.2.2.X
        case hdd
          when 0..2999 then
            return 0 #climate zone 4
          when 3000..3999 then
            return 1 #climate zone 5
          when 4000..4999 then
            return 2 #climate zone 6
          when 5000..5999 then
            return 3 #climate zone 7a
          when 6000..6999 then
            return 4 #climate zone 7b
          when 7000..1000000 then
            return 5 #climate zone 8
        end
      end

      #This model gets the climate zone name and returns the climate zone string.
      #@author phylroy.lopez@nrcan.gc.ca
      #@param hdd [Float]
      #@return [Fixnum] climate zone 4-8
      def self.get_climate_zone_name(hdd)
        case self.get_climate_zone_index(hdd)
          when 0 then
            return "4"
          when 1 then
            return "5" #climate zone 5
          when 2 then
            return "6" #climate zone 6
          when 3 then
            return "7a" #climate zone 7a
          when 4 then
            return "7b" #climate zone 7b
          when 5 then
            return "8" #climate zone 8
        end
      end


      #Set all external surface conductances to NECB values.
      #@author phylroy.lopez@nrcan.gc.ca
      #@param surface [String]
      #@param hdd [Float]
      #@param is_radiant [Boolian]
      #@param scaling_factor [Float]
      #@return [String] surface as RSI
      def self.set_necb_external_surface_conductance(surface, hdd, is_radiant = false, scaling_factor = 1.0)
        conductance_value = 0
        climate_zone_index = self.get_climate_zone_index(hdd)

        if surface.outsideBoundaryCondition.downcase == "outdoors"

          case surface.surfaceType.downcase
            when "wall"
              conductance_value = BTAP::Compliance::NECB2011::Data::Conductances::Wall[climate_zone_index] * scaling_factor
            when "floor"
              conductance_value = BTAP::Compliance::NECB2011::Data::Conductances::Floor[climate_zone_index] * scaling_factor
            when "roofceiling"
              conductance_value = BTAP::Compliance::NECB2011::Data::Conductances::Roof[climate_zone_index]
          end
          if (is_radiant)
            conductance_value = conductance_value * 0.80
          end
          return BTAP::Geometry::Surfaces::set_surfaces_construction_conductance([surface], conductance_value)
        end


        if surface.outsideBoundaryCondition.downcase.match(/ground/)
          case surface.surfaceType.downcase
            when "wall"
              conductance_value = BTAP::Compliance::NECB2011::Data::Conductances::GroundWall[BTAP::Compliance::NECB2011::get_climate_zone_index(@hdd)]
            when "floor"
              conductance_value = BTAP::Compliance::NECB2011::Data::Conductances::GroundFloor[BTAP::Compliance::NECB2011::get_climate_zone_index(@hdd)]
            when "roofceiling"
              conductance_value = BTAP::Compliance::NECB2011::Data::Conductances::GroundRoof[BTAP::Compliance::NECB2011::get_climate_zone_index(@hdd)]
          end
          if (is_radiant)
            conductance_value = conductance_value * 0.80
          end
          return BTAP::Geometry::Surfaces::set_surfaces_construction_conductance([surface], conductance_value)

        end
      end

      #Set all external subsurfaces (doors, windows, skylights) to NECB values.
      #@author phylroy.lopez@nrcan.gc.ca
      #@param subsurface [String]
      #@param hdd [Float]
      def self.set_necb_external_subsurface_conductance(subsurface, hdd)
        conductance_value = 0
        climate_zone_index = get_climate_zone_index(hdd)
        if subsurface.outsideBoundaryCondition.downcase.match("outdoors")
          case subsurface.subSurfaceType.downcase
            when /window/
              conductance_value = BTAP::Compliance::NECB2011::Data::Conductances::Window[climate_zone_index]
            when /door/
              conductance_value = BTAP::Compliance::NECB2011::Data::Conductance::Door[climate_zone_index]
          end
          subsurface.setRSI(1/conductance_value)
        end
      end







      def self.set_wildcard_schedules_to_dominant_building_schedule(model, runner = nil)

        new_sched_ruleset = OpenStudio::Model::DefaultScheduleSet.new(model) #initialize
        BTAP::runner_register("Info", "set_wildcard_schedules_to_dominant_building_schedule", runner)
        #Set wildcard schedules based on dominant schedule type in building.
        dominant_sched_type = BTAP::Compliance::NECB2011::determine_dominant_necb_schedule_type(model)
        #puts "dominant_sched_type = #{dominant_sched_type}"
        # find schedule set that corresponds to dominant schedule type
        model.getDefaultScheduleSets.sort.each do |sched_ruleset|
          # just check people schedule
          # TO DO: should make this smarter: check all schedules
          people_sched = sched_ruleset.numberofPeopleSchedule
          people_sched_name = people_sched.get.name.to_s unless people_sched.empty?

          search_string = "NECB-#{dominant_sched_type}"

          if people_sched.empty? == false
            if people_sched_name.include? search_string
              new_sched_ruleset = sched_ruleset
            end
          end
        end

        # replace the default schedule set for the space type with * to schedule ruleset with dominant schedule type

        model.getSpaces.sort.each do |space|
          #check to see if space space type has a "*" wildcard schedule.
          spacetype_name = space.spaceType.get.name.to_s unless space.spaceType.empty?
          if determine_necb_schedule_type(space).to_s == "*".to_s
            new_sched = (spacetype_name).to_s
            optional_spacetype = model.getSpaceTypeByName(new_sched)
            if optional_spacetype.empty?
              BTAP::runner_register("Error", "Cannot find NECB spacetype #{new_sched}", runner)
            else
              BTAP::runner_register("Info", "Setting wildcard spacetype #{spacetype_name} default schedule set to #{new_sched_ruleset.name}", runner)
              optional_spacetype.get.setDefaultScheduleSet(new_sched_ruleset) #this works!
            end
          end
        end # end of do |space|

        return true
      end

      def self.set_zones_thermostat_schedule_based_on_space_type_schedules(model, runner = nil)
        puts "in set_zones_thermostat_schedule_based_on_space_type_schedules"
        BTAP::runner_register("DEBUG", "Start-set_zones_thermostat_schedule_based_on_space_type_schedules", runner)
        model.getThermalZones.sort.each do |zone|
          BTAP::runner_register("DEBUG", "Zone = #{zone.name} Spaces =#{zone.spaces.size} ", runner)
          array = []

          zone.spaces.sort.each do |space|
            schedule_type = BTAP::Compliance::NECB2011::determine_necb_schedule_type(space).to_s
            BTAP::runner_register("DEBUG", "space name/type:#{space.name}/#{schedule_type}", runner)

            # if wildcard space type, need to get dominant schedule type
            if "*".to_s == schedule_type
              dominant_sched_type = BTAP::Compliance::NECB2011::determine_dominant_necb_schedule_type(model)
              schedule_type = dominant_sched_type
            end

            array << schedule_type
          end
          array.uniq!
          if array.size > 1
            BTAP::runner_register("Error", "#{zone.name} has spaces with different schedule types. Please ensure that all the spaces are of the same schedule type A to I.", runner)
            return false
          end


          htg_search_string = "NECB-#{array[0]}-Thermostat Setpoint-Heating"
          clg_search_string = "NECB-#{array[0]}-Thermostat Setpoint-Cooling"

          if model.getScheduleRulesetByName(htg_search_string).empty? == false
            htg_sched = model.getScheduleRulesetByName(htg_search_string).get
          else
            BTAP::runner_register("ERROR", "heating_thermostat_setpoint_schedule NECB-#{array[0]} does not exist", runner)
            return false
          end

          if model.getScheduleRulesetByName(clg_search_string).empty? == false
            clg_sched = model.getScheduleRulesetByName(clg_search_string).get
          else
            BTAP::runner_register("ERROR", "cooling_thermostat_setpoint_schedule NECB-#{array[0]} does not exist", runner)
            return false
          end

          name = "NECB-#{array[0]}-Thermostat Dual Setpoint Schedule"

          # If dual setpoint already exists, use that one, else create one       
          if model.getThermostatSetpointDualSetpointByName(name).empty? == false
            ds = model.getThermostatSetpointDualSetpointByName(name).get
          else
            ds = BTAP::Resources::Schedules::create_annual_thermostat_setpoint_dual_setpoint(model, name, htg_sched, clg_sched)
          end

          thermostatClone = ds.clone.to_ThermostatSetpointDualSetpoint.get
          zone.setThermostatSetpointDualSetpoint(thermostatClone)
          BTAP::runner_register("Info", "ThermalZone #{zone.name} set to DualSetpoint Schedule NECB-#{array[0]}", runner)

        end

        BTAP::runner_register("DEBUG", "END-set_zones_thermostat_schedule_based_on_space_type_schedules", runner)
        return true
      end



      # This method confirms if the type is the proper space type
      #@author phylroy.lopez@nrcan.gc.ca
      #@param type [String]
      #@return  [String] item
      def self.is_proper_spacetype(type)
        BTAP::Compliance::NECB2011::Data::SpaceTypeData.each do |item|
          if item[0] == type
            return item
          end
        end
        return false
      end


      #This model determines the dominant NECB schedule type
      #@param model [OpenStudio::model::Model] A model object
      #return s.each [String]
      def self.determine_dominant_necb_schedule_type(model)
        # lookup necb space type properties
        space_type_properties = model.find_objects(standards_data["space_types"], {"template" => 'NECB2011'})

        # Here is a hash to keep track of the m2 running total of spacetypes for each
        # sched type.
        s = Hash[
            "A", 0,
            "B", 0,
            "C", 0,
            "D", 0,
            "E", 0,
            "F", 0,
            "G", 0,
            "H", 0,
            "I", 0
        ]
        #iterate through spaces in building.
        wildcard_spaces = 0
        model.getSpaces.sort.each do |space|
          found_space_type = false
          #iterate through the NECB spacetype property table
          space_type_properties.each do |spacetype|
            unless space.spaceType.empty?
              if space.spaceType.get.standardsSpaceType.empty? || space.spaceType.get.standardsBuildingType.empty?
                OpenStudio::logFree(OpenStudio::Error, "openstudio.Standards.Model", "Space #{space.name} does not have a standardSpaceType defined")
                found_space_type = false
              elsif space.spaceType.get.standardsSpaceType.get == spacetype['space_type'] && space.spaceType.get.standardsBuildingType.get == spacetype['building_type']
                if "*" == spacetype['necb_schedule_type']
                  wildcard_spaces =+1
                else
                  s[spacetype['necb_schedule_type']] = s[spacetype['necb_schedule_type']] + space.floorArea() if "*" != spacetype['necb_schedule_type'] and "- undefined -" != spacetype['necb_schedule_type']
                end
                #puts "Found #{space.spaceType.get.name} schedule #{spacetype[2]} match with floor area of #{space.floorArea()}"
                found_space_type = true
              elsif "*" != spacetype['necb_schedule_type']
                #found wildcard..will not count to total. 
                found_space_type = true
              end
            end
          end
          raise ("Did not find #{space.spaceType.get.name} in NECB space types.") if found_space_type == false
        end
        #finds max value and returns NECB schedule letter.
        raise("Only wildcard spaces in model. You need to define the actual spaces. ") if wildcard_spaces == model.getSpaces.size
        dominant_schedule = s.each {|k, v| return k.to_s if v == s.values.max}
        return dominant_schedule
      end

      #This method determines the spacetype schedule type. This will re
      #@author phylroy.lopez@nrcan.gc.ca
      #@param space [String]
      #@return [String]:["A","B","C","D","E","F","G","H","I"] spacetype
      def self.determine_necb_schedule_type(space)
        raise ("Undefined spacetype for space #{space.get.name}) if space.spaceType.empty?") if space.spaceType.empty?
        raise ("Undefined standardsSpaceType or StandardsBuildingType for space #{space.spaceType.get.name}) if space.spaceType.empty?") if space.spaceType.get.standardsSpaceType.empty? | space.spaceType.get.standardsBuildingType.empty?
        space_type_properties = space.model.find_object(standards_data["space_types"], {"template" => 'NECB2011', "space_type" => space.spaceType.get.standardsSpaceType.get, "building_type" => space.spaceType.get.standardsBuildingType.get})
        return space_type_properties['necb_schedule_type'].strip
      end


      def self.necb_spacetype_system_selection(model, heatingDesignLoad = nil, coolingDesignLoad = nil)
        spacezoning_data = Struct.new(
            :space, # the space object
            :space_name, # the space name
            :building_type_name, # space type name
            :space_type_name, # space type name
            :necb_hvac_system_selection_type, #
            :system_number, # the necb system type
            :number_of_stories, #number of stories
            :horizontal_placement, # the horizontal placement (norht, south, east, west, core)
            :vertical_placment, # the vertical placement ( ground, top, both, middle )
            :people_obj, # Spacetype people object
            :heating_capacity,
            :cooling_capacity,
            :is_dwelling_unit, #Checks if it is a dwelling unit.
            :is_wildcard)


        #Array to store schedule objects
        schedule_type_array = []


        #find the number of stories in the model this include multipliers.
        number_of_stories = 	model.getBuilding.standardsNumberOfAboveGroundStories()
        if number_of_stories.empty?
          raise ("Number of above ground stories not present in geometry model. Please ensure this is defined in your Building Object")
        else
          number_of_stories = number_of_stories.get
        end

        #set up system array containers. These will contain the spaces associated with the system types.
        space_zoning_data_array = []

        #First pass of spaces to collect information into the space_zoning_data_array .
        model.getSpaces.sort.each do |space|


          #this will get the spacetype system index 8.4.4.8A  from the SpaceTypeData and BuildingTypeData in  (1-12)
          space_system_index = nil
          if space.spaceType.empty?
            space_system_index = nil
          else
            #gets row information from standards spreadsheet.
            space_type_property = space.model.find_object(standards_data["space_types"], {"template" => 'NECB2011', "space_type" => space.spaceType.get.standardsSpaceType.get, "building_type" => space.spaceType.get.standardsBuildingType.get})
            raise("could not find necb system selection type for space: #{space.name} and spacetype #{space.spaceType.get.standardsSpaceType.get}") if space_type_property.nil?
            #stores the Building or SpaceType System type name.
            necb_hvac_system_selection_type = space_type_property['necb_hvac_system_selection_type']
          end


          #Get the heating and cooling load for the space. Only Zones with a defined thermostat will have a load.
          #Make sure we don't have sideeffects by changing the argument variables.
          cooling_load = coolingDesignLoad
          heating_load = heatingDesignLoad
          if space.spaceType.get.standardsSpaceType.get == "- undefined -"
            cooling_load = 0.0
            heating_load = 0.0
          else
            cooling_load = space.thermalZone.get.coolingDesignLoad.get * space.floorArea * space.multiplier / 1000.0 if cooling_load.nil?
            heating_load = space.thermalZone.get.heatingDesignLoad.get * space.floorArea * space.multiplier / 1000.0 if heating_load.nil?
          end

          #identify space-system_index and assign the right NECB system type 1-7.
          system = nil
          is_dwelling_unit = false
          case necb_hvac_system_selection_type
            when nil
              raise ("#{space.name} does not have an NECB system association. Please define a NECB HVAC System Selection Type in the google docs standards database.")
            when 0, "- undefined -"
              #These are spaces are undefined...so they are unconditioned and have no loads other than infiltration and no systems
              system = 0
            when "Assembly Area" #Assembly Area.
              if number_of_stories <= 4
                system = 3
              else
                system = 6
              end

            when "Automotive Area"
              system = 4

            when "Data Processing Area"
              if coolingDesignLoad > 20 #KW...need a sizing run.
                system = 2
              else
                system = 1
              end

            when "General Area" #[3,6]
              if number_of_stories <= 2
                system = 3
              else
                system = 6
              end

            when "Historical Collections Area" #[2],
              system = 2

            when "Hospital Area" #[3],
              system = 3

            when "Indoor Arena" #,[7],
              system = 7

            when "Industrial Area" #  [3] this need some thought.
              system = 3

            when "Residential/Accomodation Area" #,[1], this needs some thought.
              system = 1
              is_dwelling_unit = true

            when "Sleeping Area" #[3],
              system = 3
              is_dwelling_unit = true

            when "Supermarket/Food Services Area" #[3,4],
              system = 3

            when "Supermarket/Food Services Area - vented"
              system = 4

            when "Warehouse Area"
              system = 4

            when "Warehouse Area - refrigerated"
              system = 5
            when "Wildcard"
              system = nil
              is_wildcard = true
            else
              raise ("NECB HVAC System Selection Type #{necb_hvac_system_selection_type} not valid")
          end
          #get placement on floor, core or perimeter and if a top, bottom, middle or single story.
          horizontal_placement, vertical_placement = BTAP::Geometry::Spaces::get_space_placement(space)
          #dump all info into an array for debugging and iteration.
          unless space.spaceType.empty?
            space_type_name = space.spaceType.get.standardsSpaceType.get
            building_type_name = space.spaceType.get.standardsBuildingType.get
            space_zoning_data_array << spacezoning_data.new(space,
                                                            space.name.get,
                                                            building_type_name,
                                                            space_type_name,
                                                            necb_hvac_system_selection_type,
                                                            system,
                                                            number_of_stories,
                                                            horizontal_placement,
                                                            vertical_placement,
                                                            space.spaceType.get.people,
                                                            heating_load,
                                                            cooling_load,
                                                            is_dwelling_unit,
                                                            is_wildcard
            )
            schedule_type_array << BTAP::Compliance::NECB2011::determine_necb_schedule_type(space).to_s
          end
        end


        return schedule_type_array.uniq!, space_zoning_data_array
      end


      # This method will take a model that uses NECB2011 spacetypes , and..
      # 1. Create a building story schema.
      # 2. Remove all existing Thermal Zone defintions.
      # 3. Create new thermal zones based on the following definitions.
      # Rule1 all zones must contain only the same schedule / occupancy schedule.
      # Rule2 zones must cater to similar solar gains (N,E,S,W)
      # Rule3 zones must not pass from floor to floor. They must be contained to a single floor or level.
      # Rule4 Wildcard spaces will be associated with the nearest zone of similar schedule type in which is shared most of it's internal surface with.
      # Rule5 For NECB zones must contain spaces of similar system type only.
      # Rule6 Residential / dwelling units must not share systems with other space types.
      # @author phylroy.lopez@nrcan.gc.ca
      # @param model [OpenStudio::model::Model] A model object
      # @return [String] system_zone_array
      def self.necb_autozone_and_autosystem(
          model = nil,
              runner = nil,
              use_ideal_air_loads = false,
              boiler_fueltype = "NaturalGas",
              mau_type = true,
              mau_heating_coil_type = "Hot Water",
              baseboard_type = "Hot Water",
              chiller_type = "Scroll",
              mua_cooling_type = "DX",
              heating_coil_types_sys3 = "Gas",
              heating_coil_types_sys4 = "Gas",
              heating_coil_types_sys6 = "Hot Water",
              fan_type = "AF_or_BI_rdg_fancurve",
              swh_fueltype = "NaturalGas",
              building_type = nil)

        #Create a data struct for the space to system to placement information.


        #system assignment.
        unless ["NaturalGas", "Electricity", "PropaneGas", "FuelOil#1", "FuelOil#2", "Coal", "Diesel", "Gasoline", "OtherFuel1"].include?(boiler_fueltype)
          BTAP::runner_register("ERROR", "boiler_fueltype = #{boiler_fueltype}", runner)
          return
        end

        unless [true, false].include?(mau_type)
          BTAP::runner_register("ERROR", "mau_type = #{mau_type}", runner)
          return
        end

        unless ["Hot Water", "Electric"].include?(mau_heating_coil_type)
          BTAP::runner_register("ERROR", "mau_heating_coil_type = #{mau_heating_coil_type}", runner)
          return false
        end

        unless ["Hot Water", "Electric"].include?(baseboard_type)
          BTAP::runner_register("ERROR", "baseboard_type = #{baseboard_type}", runner)
          return false
        end


        unless ["Scroll", "Centrifugal", "Rotary Screw", "Reciprocating"].include?(chiller_type)
          BTAP::runner_register("ERROR", "chiller_type = #{chiller_type}", runner)
          return false
        end
        unless ["DX", "Hydronic"].include?(mua_cooling_type)
          BTAP::runner_register("ERROR", "mua_cooling_type = #{mua_cooling_type}", runner)
          return false
        end

        unless ["Electric", "Gas", "DX"].include?(heating_coil_types_sys3)
          BTAP::runner_register("ERROR", "heating_coil_types_sys3 = #{heating_coil_types_sys3}", runner)
          return false
        end

        unless ["Electric", "Gas", "DX"].include?(heating_coil_types_sys4)
          BTAP::runner_register("ERROR", "heating_coil_types_sys4 = #{heating_coil_types_sys4}", runner)
          return false
        end

        unless ["Hot Water", "Electric"].include?(heating_coil_types_sys6)
          BTAP::runner_register("ERROR", "heating_coil_types_sys6 = #{heating_coil_types_sys6}", runner)
          return false
        end

        unless ["AF_or_BI_rdg_fancurve", "AF_or_BI_inletvanes", "fc_inletvanes", "var_speed_drive"].include?(fan_type)
          BTAP::runner_register("ERROR", "fan_type = #{fan_type}", runner)
          return false
        end
        # REPEATED CODE!!
        unless ["Electric", "Hot Water"].include?(heating_coil_types_sys6)
          BTAP::runner_register("ERROR", "heating_coil_types_sys6 = #{heating_coil_types_sys6}", runner)
          return false
        end
        # REPEATED CODE!!
        unless ["Electric", "Gas"].include?(heating_coil_types_sys4)
          BTAP::runner_register("ERROR", "heating_coil_types_sys4 = #{heating_coil_types_sys4}", runner)
          return false
        end

        # Ensure that floors have been assigned by user.
        raise("No building stories have been defined.. User must define building stories and spaces in model.") unless model.getBuildingStorys.size > 0
        #BTAP::Geometry::BuildingStoreys::auto_assign_stories(model)

        #this method will determine the spaces that should be set to each system
        schedule_type_array, space_zoning_data_array = self.necb_spacetype_system_selection(model, nil, nil)

        #Deal with Wildcard spaces. Might wish to have logic to do coridors first.
        space_zoning_data_array.sort{|obj1, obj2| obj1.space_name <=> obj2.space_name}.each do |space_zone_data|
          #If it is a wildcard space.
          if space_zone_data.system_number.nil?
            #iterate through all adjacent spaces from largest shared wall area to smallest.
            # Set system type to match first space system that is not nil.
            adj_spaces = space_zone_data.space.get_adjacent_spaces_with_shared_wall_areas(true)
            if adj_spaces.nil?
              puts ("Warning: No adjacent spaces for #{space_zone_data.space.name} on same floor, looking for others above and below to set system")
              adj_spaces = space_zone_data.space.get_adjacent_spaces_with_shared_wall_areas(false)
            end
            adj_spaces.sort.each do |adj_space|
              #if there are no adjacent spaces. Raise an error.
              raise ("Could not determine adj space to space #{space_zone_data.space.name.get}") if adj_space.nil?
              adj_space_data = space_zoning_data_array.find {|data| data.space == adj_space[0]}
              if adj_space_data.system_number.nil?
                next
              else
                space_zone_data.system_number = adj_space_data.system_number
                puts "#{space_zone_data.space.name.get}"
                break
              end
            end
            raise ("Could not determine adj space system to space #{space_zone_data.space.name.get}") if space_zone_data.system_number.nil?
          end
        end


        #remove any thermal zones used for sizing to start fresh. Should only do this after the above system selection method.
        model.getThermalZones.sort.each {|zone| zone.remove}


        #now lets apply the rules.
        # Rule1 all zones must contain only the same schedule / occupancy schedule.
        # Rule2 zones must cater to similar solar gains (N,E,S,W)
        # Rule3 zones must not pass from floor to floor. They must be contained to a single floor or level.
        # Rule4 Wildcard spaces will be associated with the nearest zone of similar schedule type in which is shared most of it's internal surface with.
        # Rule5 NECB zones must contain spaces of similar system type only.
        # Rule6 Multiplier zone will be part of the floor and orientation of the base space.
        # Rule7 Residential / dwelling units must not share systems with other space types.
        #Array of system types of Array of Spaces
        system_zone_array = []
        #Lets iterate by system
        (0..7).each do |system_number|
          system_zone_array[system_number] = []
          #iterate by story
          story_counter = 0
          model.getBuildingStorys.sort.each do |story|
            #puts "Story:#{story}"
            story_counter = story_counter + 1
            #iterate by operation schedule type.
            schedule_type_array.each do |schedule_type|
              #iterate by horizontal location
              ["north", "east", "west", "south", "core"].each do |horizontal_placement|
                #puts "horizontal_placement:#{horizontal_placement}"
                [true, false].each do |is_dwelling_unit|
                  space_array = Array.new
                  space_zoning_data_array.each do |space_info|
                    #puts "Spacename: #{space_info.space.name}:#{space_info.space.spaceType.get.name}"
                    if space_info.system_number == system_number and
                        space_info.space.buildingStory.get == story and
                        BTAP::Compliance::NECB2011::determine_necb_schedule_type(space_info.space).to_s == schedule_type and
                        space_info.horizontal_placement == horizontal_placement and
                        space_info.is_dwelling_unit == is_dwelling_unit
                      space_array << space_info.space
                    end
                  end

                  #create Thermal Zone if space_array is not empty.
                  if space_array.size > 0
                    # Process spaces that have multipliers associated with them first.
                    # This map define the multipliers for spaces with multipliers not equals to 1
                    space_multiplier_map = {}
                    # This map define the multipliers for spaces with multipliers not equals to 1
                    case building_type
                      when 'LargeHotel'
                        space_multiplier_map = PrototypeBuilding::LargeHotel.define_space_multiplier
                      when 'MidriseApartment'
                        space_multiplier_map = PrototypeBuilding::MidriseApartment.define_space_multiplier
                      when 'LargeOffice'
                        space_multiplier_map = PrototypeBuilding::LargeOffice.define_space_multiplier
					  when 'LargeOfficeDetailed'
                        space_multiplier_map = PrototypeBuilding::LargeOfficeDetailed.define_space_multiplier	
                      when 'Hospital'
                        space_multiplier_map = PrototypeBuilding::Hospital.define_space_multiplier
                      else
                        space_multiplier_map = {}
                    end
                    #create new zone and add the spaces to it.
                    space_array.each do |space|
                      # Create thermalzone for each space.
                      thermal_zone = OpenStudio::Model::ThermalZone.new(model)
                      # Create a more informative space name.
                      thermal_zone.setName("Sp-#{space.name} Sys-#{system_number.to_s} Flr-#{story_counter.to_s} Sch-#{schedule_type.to_s} HPlcmt-#{horizontal_placement} ZN")
                      # Add zone mulitplier if required.
                      thermal_zone.setMultiplier(space_multiplier_map[space.name.to_s]) unless space_multiplier_map[space.name.to_s].nil?
                      # Space to thermal zone. (for archetype work it is one to one)
                      space.setThermalZone(thermal_zone)
                      # Get thermostat for space type if it already exists.
                      space_type_name = space.spaceType.get.name.get
                      thermostat_name = space_type_name + ' Thermostat'
                      thermostat = model.getThermostatSetpointDualSetpointByName(thermostat_name)
                      if thermostat.empty?
                        OpenStudio::logFree(OpenStudio::Error, 'openstudio.model.Model', "Thermostat #{thermostat_name} not found for space name: #{space.name} ZN")
                        raise (" Thermostat #{thermostat_name} not found for space name: #{space.name}")
                      else
                        thermostatClone = thermostat.get.clone(model).to_ThermostatSetpointDualSetpoint.get
                        thermal_zone.setThermostatSetpointDualSetpoint(thermostatClone)
                      end
                      # Add thermal to zone system number.
                      system_zone_array[system_number] << thermal_zone
                    end
                  end
                end
              end
            end
          end
        end #system iteration

        #Create and assign the zones to the systems.
        unless use_ideal_air_loads == true
          hw_loop_needed = false
          system_zone_array.each_with_index do |zones, system_index|
            next if zones.size == 0
            if (system_index == 1 && (mau_heating_coil_type == 'Hot Water' || baseboard_type == 'Hot Water'))
              hw_loop_needed = true
            elsif (system_index == 2 || system_index == 5 || system_index == 7)
              hw_loop_needed = true
            elsif ((system_index == 3 || system_index == 4) && baseboard_type == 'Hot Water')
              hw_loop_needed = true
            elsif (system_index == 6 && (mau_heating_coil_type == 'Hot Water' || baseboard_type == 'Hot Water'))
              hw_loop_needed = true
            end
            if (hw_loop_needed) then
              break
            end
          end
          if (hw_loop_needed)
            hw_loop = OpenStudio::Model::PlantLoop.new(model)
            always_on = model.alwaysOnDiscreteSchedule
            BTAP::Resources::HVAC::HVACTemplates::NECB2011::setup_hw_loop_with_components(model, hw_loop, boiler_fueltype, always_on)
          end
          system_zone_array.each_with_index do |zones, system_index|
            #skip if no thermal zones for this system.
            next if zones.size == 0
            #            puts "Zone Names for System #{system_index}"
            #            puts "system_index = #{system_index}"
            case system_index
              when 0, nil
                #Do nothing no system assigned to zone. Used for Unconditioned spaces
              when 1
                BTAP::Resources::HVAC::HVACTemplates::NECB2011::assign_zones_sys1(model, zones, boiler_fueltype, mau_type, mau_heating_coil_type, baseboard_type, hw_loop)
              when 2
                BTAP::Resources::HVAC::HVACTemplates::NECB2011::assign_zones_sys2(model, zones, boiler_fueltype, chiller_type, mua_cooling_type)
              when 3
                BTAP::Resources::HVAC::HVACTemplates::NECB2011::assign_zones_sys3(model, zones, boiler_fueltype, heating_coil_types_sys3, baseboard_type, hw_loop)
              when 4
                BTAP::Resources::HVAC::HVACTemplates::NECB2011::assign_zones_sys4(model, zones, boiler_fueltype, heating_coil_types_sys4, baseboard_type, hw_loop)
              when 5
                BTAP::Resources::HVAC::HVACTemplates::NECB2011::assign_zones_sys5(model, zones, boiler_fueltype, chiller_type, mua_cooling_type)
              when 6
                BTAP::Resources::HVAC::HVACTemplates::NECB2011::assign_zones_sys6(model, zones, boiler_fueltype, heating_coil_types_sys6, baseboard_type, chiller_type, fan_type, hw_loop)
              when 7
                BTAP::Resources::HVAC::HVACTemplates::NECB2011::assign_zones_sys7(model, zones, boiler_fueltype, chiller_type, mua_cooling_type)
            end
          end
        else
          #otherwise use ideal loads.
          model.getThermalZones.sort.each do |thermal_zone|
            thermal_zone_ideal_loads = OpenStudio::Model::ZoneHVACIdealLoadsAirSystem.new(model)
            thermal_zone_ideal_loads.addToThermalZone(thermal_zone)
          end
        end
        #Check to ensure that all spaces are assigned to zones except undefined ones.
        errors = []
        model.getSpaces.sort.each do |space|
          if space.thermalZone.empty? and space.spaceType.get.name.get != 'Space Function - undefined -'
            errors << "space #{space.name} with spacetype #{space.spaceType.get.name.get} was not assigned a thermalzone."
          end
        end
        if errors.size > 0
          raise(" #{errors}")
        end
      end #
    end
  end #Compliance
end