# *******************************************************************************
# OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
# See also https://openstudio.net/license
# *******************************************************************************

module OsLib_ModelSimplification
  # get all loads for a space_or_space_type and place in hash by type
  def gather_internal_loads(space_or_space_type)
    internal_load_hash = {}

    # gather different load types (all vectors except dsoa which will be turned into an array)
    internal_load_hash[:internal_mass] = space_or_space_type.internalMass
    internal_load_hash[:people] = space_or_space_type.people
    internal_load_hash[:lights] = space_or_space_type.lights
    internal_load_hash[:luminaires] = space_or_space_type.luminaires
    internal_load_hash[:electric_equipment] = space_or_space_type.electricEquipment
    internal_load_hash[:gas_equipment] = space_or_space_type.gasEquipment
    internal_load_hash[:hot_water_equipment] = space_or_space_type.hotWaterEquipment
    internal_load_hash[:steam_equipment] = space_or_space_type.steamEquipment
    internal_load_hash[:other_equipment] = space_or_space_type.otherEquipment
    internal_load_hash[:space_infiltration_design_flow_rates] = space_or_space_type.spaceInfiltrationDesignFlowRates
    internal_load_hash[:space_infiltration_effective_leakage_areas] = space_or_space_type.spaceInfiltrationEffectiveLeakageAreas
    if space_or_space_type.designSpecificationOutdoorAir.nil?
      internal_load_hash[:design_specification_outdoor_air] = []
    else
      internal_load_hash[:design_specification_outdoor_air] = [space_or_space_type.designSpecificationOutdoorAir]
    end
    if space_or_space_type.class.to_s == 'OpenStudio::Model::Space'
      internal_load_hash[:water_use_equipment] = space_or_space_type.waterUseEquipment # don't think this reports
      internal_load_hash[:daylighting_controls] = space_or_space_type.daylightingControls
    end

    # TODO: - warn if daylighting controls in spaces (should I alter fraction controled based on lighting per area ratio)

    return internal_load_hash
  end

  # blend_space_types_from_floor_area_ratio used when working from space type ratio and un-assigned space types
  def blend_space_types_from_floor_area_ratio(runner, model, space_type_ratio_hash)
    # create stub blended space type
    blended_space_type = OpenStudio::Model::SpaceType.new(model)
    blended_space_type.setName('Blended Space Type')

    # TODO: - inspect people instances and see if any defs are not normalized per area. If find any issue warning

    # gather inputs
    sum_of_num_people_per_m_2 = 0.0
    space_type_ratio_hash.each do |space_type, ratios|
      # get number of peple per m 2 for space type. Can do this without looking at instances
      sum_of_num_people_per_m_2 += space_type.getPeoplePerFloorArea(1.0)
    end

    # raw num_people_ratios
    sum_area_adj_num_people_ratio = 0.0
    space_type_ratio_hash.each do |space_type, ratios|
      # calculate num_people_ratios
      area_adj_num_people_ratio  = (space_type.getPeoplePerFloorArea(1.0) / sum_of_num_people_per_m_2) * ratios[:floor_area_ratio]
      sum_area_adj_num_people_ratio += area_adj_num_people_ratio
    end

    # set ratios
    largest_space_type = nil
    largest_space_type_ratio = 0.00
    space_type_ratio_hash.each do |space_type, ratios|
      # calculate num_people_ratios
      area_adj_num_people_ratio = (space_type.getPeoplePerFloorArea(1.0) / sum_of_num_people_per_m_2) * ratios[:floor_area_ratio]
      normalized_area_adj_num_people_ratio = area_adj_num_people_ratio / sum_area_adj_num_people_ratio

      # ratios[:floor_area_ratio] is already defined
      ratios[:num_people_ratio] = normalized_area_adj_num_people_ratio.round(4)
      ratios[:ext_surface_area_ratio] = ratios[:floor_area_ratio]
      ratios[:ext_wall_area_ratio] = ratios[:floor_area_ratio]
      ratios[:volume_ratio] = ratios[:floor_area_ratio]

      # update largest space type values
      if largest_space_type.nil?
        largest_space_type = space_type
        largest_space_type_ratio = ratios[:floor_area_ratio]
      elsif ratios[:floor_area_ratio] > largest_space_type_ratio
        largest_space_type = space_type
        largest_space_type_ratio = ratios[:floor_area_ratio]
      end
    end

    if largest_space_type.nil?
      runner.registerError("Didn't find any space types in model matching user argument string.")
      return nil
    end

    # set standards info for space type based on largest ratio (for use to apply HVAC system)
    standards_building_type = largest_space_type.standardsBuildingType
    standards_space_type = largest_space_type.standardsSpaceType
    if standards_building_type.is_initialized
      blended_space_type.setStandardsBuildingType(standards_building_type.get)
    end
    if standards_space_type.is_initialized
      blended_space_type.setStandardsSpaceType(standards_space_type.get)
    end

    # loop therough space types to get instances from and then remove
    space_type_ratio_hash.each do |space_type, ratios|
      # blend internal loads (nil is space_hash)
      space_type_load_instances = blend_internal_loads(runner, model, space_type, blended_space_type, ratios, model.getBuilding.floorArea, nil)
      runner.registerInfo("Blending #{space_type.name.get} with floor area ratio of #{ratios[:floor_area_ratio]} and number of people ratio of #{ratios[:num_people_ratio]}.")

      # delete space type. Don't want to leave in model since internal loads  have been removed from it
      space_type.remove
    end

    return blended_space_type
  end

  # takes in space type hash where each hash value is a colleciton of space types. Each collection is blended into it's own space type
  # If key for any collection is "Building" it will also opererate on spaces that don't have space type assigned
  # where a space assigned to a space type from a collection has space loads, those space loads are normalized and added to the blended space type
  # load instances are maintained so that they can haave unique schedules, and can have EE measures selectivly applied.
  def blend_space_type_collections(runner, model, space_type_hash)
    # loop through building type hash to create multiple blends
    space_type_hash.each do |collection_name, space_types|
      if collection_name == 'Building'
        space_array = model.getSpaces.sort # use all space types, not just space types passed in
      else
        space_array = []
        space_types.each do |space_type|
          space_array.concat(space_type.spaces)
        end
      end

      # calculate metrics for all spaces included in building area to pass into space_type and space hash
      # note: in the future this may be a subset of spaces if blending into multiple space types vs. just one.
      collection_totals = {}
      collection_totals[:floor_area] = 0.0
      collection_totals[:num_people] = 0.0
      collection_totals[:ext_surface_area] = 0.0
      collection_totals[:ext_wall_area] = 0.0
      collection_totals[:volume] = 0.0
      space_array.each do |space|
        next if !space.partofTotalFloorArea
        collection_totals[:floor_area] += space.floorArea * space.multiplier
        collection_totals[:num_people] += space.numberOfPeople * space.multiplier
        collection_totals[:ext_surface_area] += space.exteriorArea * space.multiplier
        collection_totals[:ext_wall_area] += space.exteriorWallArea * space.multiplier
        collection_totals[:volume] += space.volume * space.multiplier
      end
      area_ip = OpenStudio.convert(collection_totals[:floor_area], 'm^2', 'ft^2').get
      area_ip_neat = OpenStudio.toNeatString(area_ip, 2, true)
      runner.registerInfo("#{collection_name} area is #{area_ip_neat} ft^2, number of people is #{collection_totals[:num_people].round(0)}.")

      # create hash of space types and floor area for all space types with area > 0 when spaces included in floor area
      # code to gather space type areas came from openstudio_results measure.
      space_type_hash = {}
      largest_space_type = nil
      largest_space_type_ratio = 0.00
      space_types.each do |space_type|
        next if space_type.floorArea == 0
        space_type_totals = {}
        space_type_totals[:floor_area] = 0.0
        space_type_totals[:num_people] = 0.0
        space_type_totals[:ext_surface_area] = 0.0
        space_type_totals[:ext_wall_area] = 0.0
        space_type_totals[:volume] = 0.0
        # loop through spaces so I can skip if not included in floor area
        space_type.spaces.each do |space|
          next if !space.partofTotalFloorArea
          space_type_totals[:floor_area] += space.floorArea * space.multiplier
          space_type_totals[:num_people] += space.numberOfPeople * space.multiplier
          space_type_totals[:ext_surface_area] += space.exteriorArea * space.multiplier
          space_type_totals[:ext_wall_area] += space.exteriorWallArea * space.multiplier
          space_type_totals[:volume] += space.volume * space.multiplier
        end

        # update largest space type values
        if largest_space_type.nil?
          largest_space_type = space_type
          largest_space_type_ratio = space_type_totals[:floor_area]
        elsif space_type_totals[:floor_area] > largest_space_type_ratio
          largest_space_type = space_type
          largest_space_type_ratio = space_type_totals[:floor_area]
        end

        # gather internal loads
        space_type_loads_hash = gather_internal_loads(space_type)

        # don't add to hash if no spaces used for space type are included in building area (e.g. plenum and attic)
        # todo - log these and decide what to do for them. Leave loads alone or remove, do they add to blend at all?
        next if space_type_totals[:floor_area] == 0

        if !space_type_totals[:floor_area] = space_type.floorArea # TODO: - not sure if these would ever show as different
          runner.registerWarning("Some but not all spaces of #{space_type.name} space type are not included in the building floor area. May have unexpected results")
        end

        # populate space type hash
        space_type_hash[space_type] = { int_loads: space_type_loads_hash, totals: space_type_totals }
      end

      # report initial condition of model
      runner.registerInfo("#{collection_name} accounts for #{space_type_hash.size} space types.")

      if collection_name == 'Building'
        # count area of spaces that have no space type
        no_space_type_area_counter = 0
        model.getSpaces.sort.each do |space|
          if space.spaceType.empty?
            next if !space.partofTotalFloorArea
            no_space_type_area_counter += space.floorArea * space.multiplier
          end
        end
        floor_area_ratio = no_space_type_area_counter / collection_totals[:floor_area]
        if floor_area_ratio > 0
          runner.registerInfo("#{floor_area_ratio} fraction of building area is composed of spaces without space type assignments.")
        end
      end

      # report the space ratio for hard spaces
      space_hash = {}
      space_array.each do |space|
        next if !space.partofTotalFloorArea
        space_loads_hash = gather_internal_loads(space)
        space_totals = {}
        space_totals[:floor_area] = space.floorArea * space.multiplier
        space_totals[:num_people] = space.numberOfPeople * space.multiplier
        space_totals[:ext_surface_area] = space.exteriorArea * space.multiplier
        space_totals[:ext_wall_area] = space.exteriorWallArea * space.multiplier
        space_totals[:volume] = space.volume * space.multiplier
        if !space_loads_hash[:daylighting_controls].empty?
          runner.registerWarning("#{space.name} has one or more daylighting controls. Lighting loads from blended space type may affect lighting reduction from daylighting controls.")
        end
        if !space_loads_hash[:water_use_equipment].empty?
          runner.registerInfo("One ore more water use equipment objects are associated with space #{space.name}. This can't be moved to a space type.")
        end
        # note: If generating ratios without geometry can calculate people_ratio given space_types floor_area_ratio
        space_hash[space] = { int_loads: space_loads_hash, totals: space_totals }
      end

      # create stub blended space type
      blended_space_type = OpenStudio::Model::SpaceType.new(model)
      blended_space_type.setName("#{collection_name} Blended Space Type")

      # set standards info for space type based on largest ratio (for use to apply HVAC system)
      standards_building_type = largest_space_type.standardsBuildingType
      standards_space_type = largest_space_type.standardsSpaceType
      if standards_building_type.is_initialized
        blended_space_type.setStandardsBuildingType(standards_building_type.get)
      end
      if standards_space_type.is_initialized
        blended_space_type.setStandardsSpaceType(standards_space_type.get)
      end

      # values from collection hash
      collection_floor_area = collection_totals[:floor_area]
      collection_num_people = collection_totals[:num_people]
      collection_ext_surface_area = collection_totals[:ext_surface_area]
      collection_ext_wall_area = collection_totals[:ext_wall_area]
      collection_volume = collection_totals[:volume]

      # loop through space that have one or more spaces included in the building area
      space_type_hash.each do |space_type, hash|
        # hard assign space load schedules before re-assign instances to blended space type
        space_type.hardApplySpaceLoadSchedules

        # vaules from space or space_type
        floor_area = hash[:totals][:floor_area]
        num_people = hash[:totals][:num_people]
        ext_surface_area = hash[:totals][:ext_surface_area]
        ext_wall_area = hash[:totals][:ext_wall_area]
        volume = hash[:totals][:volume]

        # ratios
        ratios = {}
        if collection_floor_area > 0
          ratios[:floor_area_ratio] = floor_area / collection_floor_area
        else
          ratios[:floor_area_ratio] = 0.0
        end
        if collection_num_people > 0
          ratios[:num_people_ratio] = num_people / collection_num_people
        else
          ratios[:num_people_ratio] = 0.0
        end
        if collection_ext_surface_area > 0
          ratios[:ext_surface_area_ratio] = ext_surface_area / collection_ext_surface_area
        else
          ratios[:ext_surface_area_ratio] = 0.0
        end
        if collection_ext_wall_area > 0
          ratios[:ext_wall_area_ratio] = ext_wall_area / collection_ext_wall_area
        else
          ratios[:ext_wall_area_ratio] = 0.0
        end
        if collection_volume > 0
          ratios[:volume_ratio] = volume / collection_volume
        else
          ratios[:volume_ratio] = 0.0
        end

        # populate blended space type with space type loads
        space_type_load_instances = blend_internal_loads(runner, model, space_type, blended_space_type, ratios, collection_floor_area, space_hash)
        runner.registerInfo("Blending space type #{space_type.name}. Floor area ratio is #{(hash[:totals][:floor_area] / collection_totals[:floor_area]).round(3)}. People ratio is #{(hash[:totals][:num_people] / collection_totals[:num_people]).round(3)}")

        # hard assign any constructions assigned by space types, except for space not included in the building area
        if space_type.defaultConstructionSet.is_initialized
          runner.registerInfo("Hard assigning constructions for #{space_type.name}.")
          space_type.spaces.each(&:hardApplyConstructions)
        end

        # remove all space type assignments, except for spaces not included in building area.
        space_type.spaces.each do |space|
          next if !space.partofTotalFloorArea
          space.resetSpaceType
        end

        # delete space type. Don't want to leave in model since internal loads  have been removed from it
        space_type.remove
      end

      # loop through spaces that are included in building area
      space_hash.each do |space, hash|
        # hard assign space load schedules before re-assign instances to blended space type
        space.hardApplySpaceLoadSchedules

        # vaules from space or space_type
        floor_area = hash[:totals][:floor_area]
        num_people = hash[:totals][:num_people]
        ext_surface_area = hash[:totals][:ext_surface_area]
        ext_wall_area = hash[:totals][:ext_wall_area]
        volume = hash[:totals][:volume]

        # ratios
        ratios = {}
        if collection_floor_area > 0
          ratios[:floor_area_ratio] = floor_area / collection_floor_area
        else
          ratios[:floor_area_ratio] = 0.0
        end
        if collection_num_people > 0
          ratios[:num_people_ratio] = num_people / collection_num_people
        else
          ratios[:num_people_ratio] = 0.0
        end
        if collection_ext_surface_area > 0
          ratios[:ext_surface_area_ratio] = ext_surface_area / collection_ext_surface_area
        else
          ratios[:ext_surface_area_ratio] = 0.0
        end
        if collection_ext_wall_area > 0
          ratios[:ext_wall_area_ratio] = ext_wall_area / collection_ext_wall_area
        else
          ratios[:ext_wall_area_ratio] = 0.0
        end
        if collection_volume > 0
          ratios[:volume_ratio] = volume / collection_volume
        else
          ratios[:volume_ratio] = 0.0
        end

        # populate blended space type with space loads
        space_load_instances = blend_internal_loads(runner, model, space, blended_space_type, ratios, collection_floor_area, space_hash)
        next if space_load_instances.empty?
        runner.registerInfo("Blending space #{space.name}. Floor area ratio is #{(hash[:totals][:floor_area] / collection_totals[:floor_area]).round(3)}. People ratio is #{(hash[:totals][:num_people] / collection_totals[:num_people]).round(3)}")
      end

      if collection_name == 'Building'
        # assign blended space type to building
        model.getBuilding.setSpaceType(blended_space_type)
        building_space_type = model.getBuilding.spaceType
      else
        space_array.each do |space|
          space.setSpaceType(blended_space_type)
        end
      end
    end

    return model.getSpaceTypes.sort
  end

  # blend internal loads used when working from existing model
  def blend_internal_loads(runner, model, source_space_or_space_type, target_space_type, ratios, collection_floor_area, space_hash)
    # ratios
    floor_area_ratio = ratios[:floor_area_ratio]
    num_people_ratio = ratios[:num_people_ratio]
    ext_surface_area_ratio = ratios[:ext_surface_area_ratio]
    ext_wall_area_ratio = ratios[:ext_wall_area_ratio]
    volume_ratio = ratios[:volume_ratio]

    # for normalizing design level loads I need to know effective number of spaces instance is applied to
    if source_space_or_space_type.to_Space.is_initialized
      eff_num_spaces = source_space_or_space_type.multiplier
    else
      eff_num_spaces = 0
      source_space_or_space_type.spaces.each do |space|
        eff_num_spaces += space.multiplier
      end
    end

    # array of load instacnes re-assigned to blended space
    instances_array = []

    # internal_mass
    source_space_or_space_type.internalMass.each do |load_inst|
      load_def = load_inst.definition.to_InternalMassDefinition.get
      if load_def.surfaceArea.is_initialized
        # edit and assign a clone of definition and normalize per area based on floor area ratio
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          cloned_load_def = load_def.clone(model).to_InternalMass.get
          orig_design_level = cloned_load_def.surfaceArea.get
          cloned_load_def.setSurfaceAreaperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          cloned_load_def.setName("#{cloned_load_def.name} - pre-normalized value was #{orig_design_level.round} m^2.")
          load_inst.setInternalMassDefinition(cloned_load_def)
        end
      elsif load_def.surfaceAreaperSpaceFloorArea.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      elsif load_def.surfaceAreaperPerson.is_initialized
        if num_people_ratio.nil?
          runner.registerError("#{load_def} has value defined per person, but people ratio wasn't passed in")
          return false
        else
          load_inst.setMultiplier(load_inst.multiplier * num_people_ratio)
        end
      else
        runner.registerError("Unexpected value type for #{load_def.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # people
    source_space_or_space_type.people.each do |load_inst|
      load_def = load_inst.definition.to_PeopleDefinition.get
      if load_def.numberofPeople.is_initialized
        # edit and assign a clone of definition and normalize per area based on floor area ratio
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          cloned_load_def = load_def.clone(model).to_PeopleDefinition.get
          orig_design_level = cloned_load_def.numberofPeople.get
          cloned_load_def.setPeopleperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          cloned_load_def.setName("#{cloned_load_def.name} - pre-normalized value was #{orig_design_level.round} people.")
          load_inst.setPeopleDefinition(cloned_load_def)
        end
      elsif load_def.peopleperSpaceFloorArea.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      elsif load_def.spaceFloorAreaperPerson.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      else
        runner.registerError("Unexpected value type for #{load_def.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # lights
    source_space_or_space_type.lights.each do |load_inst|
      load_def = load_inst.definition.to_LightsDefinition.get
      if load_def.lightingLevel.is_initialized
        # edit and assign a clone of definition and normalize per area based on floor area ratio
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          cloned_load_def = load_def.clone(model).to_LightsDefinition.get
          orig_design_level = cloned_load_def.lightingLevel.get
          cloned_load_def.setWattsperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          cloned_load_def.setName("#{cloned_load_def.name} - pre-normalized value was #{orig_design_level.round} W.")
          load_inst.setLightsDefinition(cloned_load_def)
        end
      elsif load_def.wattsperSpaceFloorArea.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      elsif load_def.wattsperPerson.is_initialized
        if num_people_ratio.nil?
          runner.registerError("#{load_def} has value defined per person, but people ratio wasn't passed in")
          return false
        else
          load_inst.setMultiplier(load_inst.multiplier * num_people_ratio)
        end
      else
        runner.registerError("Unexpected value type for #{load_def.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # luminaires
    source_space_or_space_type.luminaires.each do |load_inst|
      # TODO: - can't normalize luminaire. Replace it with similar normalized lights def and instance
      runner.registerWarning("Can't area normalize luminaire. Instance will be applied to every space using the blended space type")
      instances_array << load_inst
    end

    # electric_equipment
    source_space_or_space_type.electricEquipment.each do |load_inst|
      load_def = load_inst.definition.to_ElectricEquipmentDefinition.get
      if load_def.designLevel.is_initialized
        # edit and assign a clone of definition and normalize per area based on floor area ratio
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          cloned_load_def = load_def.clone(model).to_ElectricEquipmentDefinition.get
          orig_design_level = cloned_load_def.designLevel.get
          cloned_load_def.setWattsperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          cloned_load_def.setName("#{cloned_load_def.name} - pre-normalized value was #{orig_design_level.round} W.")
          load_inst.setElectricEquipmentDefinition(cloned_load_def)
        end
      elsif load_def.wattsperSpaceFloorArea.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      elsif load_def.wattsperPerson.is_initialized
        if num_people_ratio.nil?
          runner.registerError("#{load_def} has value defined per person, but people ratio wasn't passed in")
          return false
        else
          load_inst.setMultiplier(load_inst.multiplier * num_people_ratio)
        end
      else
        runner.registerError("Unexpected value type for #{load_def.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # gas_equipment
    source_space_or_space_type.gasEquipment.each do |load_inst|
      load_def = load_inst.definition.to_GasEquipmentDefinition.get
      if load_def.designLevel.is_initialized
        # edit and assign a clone of definition and normalize per area based on floor area ratio
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          cloned_load_def = load_def.clone(model).to_GasEquipmentDefinition.get
          orig_design_level = cloned_load_def.designLevel.get
          cloned_load_def.setWattsperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          cloned_load_def.setName("#{cloned_load_def.name} - pre-normalized value was #{orig_design_level.round} W.")
          load_inst.setGasEquipmentDefinition(cloned_load_def)
        end
      elsif load_def.wattsperSpaceFloorArea.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      elsif load_def.wattsperPerson.is_initialized
        if num_people_ratio.nil?
          runner.registerError("#{load_def} has value defined per person, but people ratio wasn't passed in")
          return false
        else
          load_inst.setMultiplier(load_inst.multiplier * num_people_ratio)
        end
      else
        runner.registerError("Unexpected value type for #{load_def.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # hot_water_equipment
    source_space_or_space_type.hotWaterEquipment.each do |load_inst|
      load_def = load_inst.definition.to_HotWaterDefinition.get
      if load_def.designLevel.is_initialized
        # edit and assign a clone of definition and normalize per area based on floor area ratio
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          cloned_load_def = load_def.clone(model).to_HotWaterEquipmentDefinition.get
          orig_design_level = cloned_load_def.designLevel.get
          cloned_load_def.setWattsperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          cloned_load_def.setName("#{cloned_load_def.name} - pre-normalized value was #{orig_design_level.round} W.")
          load_inst.setHotWaterEquipmentDefinition(cloned_load_def)
        end
      elsif load_def.wattsperSpaceFloorArea.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      elsif load_def.wattsperPerson.is_initialized
        if num_people_ratio.nil?
          runner.registerError("#{load_def} has value defined per person, but people ratio wasn't passed in")
          return false
        else
          load_inst.setMultiplier(load_inst.multiplier * num_people_ratio)
        end
      else
        runner.registerError("Unexpected value type for #{load_def.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # steam_equipment
    source_space_or_space_type.steamEquipment.each do |load_inst|
      load_def = load_inst.definition.to_SteamDefinition.get
      if load_def.designLevel.is_initialized
        # edit and assign a clone of definition and normalize per area based on floor area ratio
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          cloned_load_def = load_def.clone(model).to_SteamEquipmentDefinition.get
          orig_design_level = cloned_load_def.designLevel.get
          cloned_load_def.setWattsperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          cloned_load_def.setName("#{cloned_load_def.name} - pre-normalized value was #{orig_design_level.round} W.")
          load_inst.setSteamEquipmentDefinition(cloned_load_def)
        end
      elsif load_def.wattsperSpaceFloorArea.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      elsif load_def.wattsperPerson.is_initialized
        if num_people_ratio.nil?
          runner.registerError("#{load_def} has value defined per person, but people ratio wasn't passed in")
          return false
        else
          load_inst.setMultiplier(load_inst.multiplier * num_people_ratio)
        end
      else
        runner.registerError("Unexpected value type for #{load_def.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # other_equipment
    source_space_or_space_type.otherEquipment.each do |load_inst|
      load_def = load_inst.definition.to_OtherDefinition.get
      if load_def.designLevel.is_initialized
        # edit and assign a clone of definition and normalize per area based on floor area ratio
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          cloned_load_def = load_def.clone(model).to_OtherEquipmentDefinition.get
          orig_design_level = cloned_load_def.designLevel.get
          cloned_load_def.setWattsperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          cloned_load_def.setName("#{cloned_load_def.name} - pre-normalized value was #{orig_design_level.round} W.")
          load_inst.setOtherEquipmentDefinition(cloned_load_def)
        end
      elsif load_def.wattsperSpaceFloorArea.is_initialized
        load_inst.setMultiplier(load_inst.multiplier * floor_area_ratio)
      elsif load_def.wattsperPerson.is_initialized
        if num_people_ratio.nil?
          runner.registerError("#{load_def} has value defined per person, but people ratio wasn't passed in")
          return false
        else
          load_inst.setMultiplier(load_inst.multiplier * num_people_ratio)
        end
      else
        runner.registerError("Unexpected value type for #{load_def.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # space_infiltration_design_flow_rates
    source_space_or_space_type.spaceInfiltrationDesignFlowRates.each do |load_inst|
      if load_inst.designFlowRateCalculationMethod == 'Flow/Space'
        # edit load so normalized for building area
        if collection_floor_area == 0
          runner.registerWarning("Can't determine building floor area to normalize #{load_def}. #{load_inst} will be asigned the the blended space without altering its values.")
        else
          orig_design_level = load_inst.designFlowRate.get
          load_inst.setFlowperSpaceFloorArea(eff_num_spaces * orig_design_level / collection_floor_area)
          load_inst.setName("#{load_inst.name} -  pre-normalized value was #{orig_design_level} m^3/sec")
        end
      elsif load_inst.designFlowRateCalculationMethod == 'Flow/Area'
        load_inst.setFlowperSpaceFloorArea(load_inst.flowperSpaceFloorArea.get * floor_area_ratio)
      elsif load_inst.designFlowRateCalculationMethod == 'Flow/ExteriorArea'
        load_inst.setFlowperExteriorSurfaceArea(load_inst.flowperExteriorSurfaceArea.get * ext_surface_area_ratio)
      elsif load_inst.designFlowRateCalculationMethod == 'Flow/ExteriorWallArea'
        load_inst.setFlowperExteriorWallArea(load_inst.flowperExteriorWallArea.get * ext_wall_area_ratio)
      elsif load_inst.designFlowRateCalculationMethod == 'AirChanges/Hour'
        load_inst.setAirChangesperHour (load_inst.airChangesperHour.get * volume_ratio)
      else
        runner.registerError("Unexpected value type for #{load_inst.name}")
        return false
      end
      load_inst.setSpaceType(target_space_type)
      instances_array << load_inst
    end

    # space_infiltration_effective_leakage_areas
    source_space_or_space_type.spaceInfiltrationEffectiveLeakageAreas.each do |load|
      # TODO: - can't normalize space_infiltration_effective_leakage_areas. Come up with logic to address this
      runner.registerWarning("Can't area normalize space_infiltration_effective_leakage_areas. It will be applied to every space using the blended space type")
      load.setSpaceType(target_space_type)
      instances_array << load
    end

    # add OA object if it doesn't already exist
    if target_space_type.designSpecificationOutdoorAir.is_initialized
      blended_oa = target_space_type.designSpecificationOutdoorAir.get
    else
      blended_oa = OpenStudio::Model::DesignSpecificationOutdoorAir.new(model)
      blended_oa.setName('Blended OA')
      blended_oa.setOutdoorAirMethod('Sum')
      target_space_type.setDesignSpecificationOutdoorAir(blended_oa)
      instances_array << blended_oa
    end

    # update OA object
    if source_space_or_space_type.designSpecificationOutdoorAir.is_initialized
      oa = source_space_or_space_type.designSpecificationOutdoorAir.get
      oa_sch = nil
      if oa.outdoorAirFlowRateFractionSchedule.is_initialized
        # TODO: - improve logic to address multiple schedules
        runner.registerWarning("Schedule #{oa.outdoorAirFlowRateFractionSchedule.get.name} assigned to #{oa.name} will be ignored. New OA object will not have a schedule assigned")
      end
      if oa.outdoorAirMethod == 'Maximum'
        # TODO: - see if way to address this by pre-calculating the max and only entering that value for space type
        runner.registerWarning("Outdoor air method of Maximum will be ignored for #{oa.name}. New OA object will have outdoor air method of Sum.")
      end
      # adjusted ratios for oa (lowered for space type if there is hard assigned oa load for one or more spaces)
      oa_floor_area_ratio = floor_area_ratio
      oa_num_people_ratio = num_people_ratio
      if source_space_or_space_type.class.to_s == 'OpenStudio::Model::SpaceType'
        source_space_or_space_type.spaces.each do |space|
          if !space.isDesignSpecificationOutdoorAirDefaulted
            if space_hash.nil?
              runner.registerWarning('No space_hash passed in and model has OA designed at space level.')
            else
              oa_floor_area_ratio -= space_hash[space][:floor_area_ratio]
              oa_num_people_ratio -= space_hash[space][:num_people_ratio]
            end
          end
        end
      end
      # add to values of blended OA load
      if oa.outdoorAirFlowperPerson > 0
        blended_oa.setOutdoorAirFlowperPerson(blended_oa.outdoorAirFlowperPerson + oa.outdoorAirFlowperPerson * oa_num_people_ratio)
      end
      if oa.outdoorAirFlowperFloorArea > 0
        blended_oa.setOutdoorAirFlowperFloorArea(blended_oa.outdoorAirFlowperFloorArea + oa.outdoorAirFlowperFloorArea * oa_floor_area_ratio)
      end
      if oa.outdoorAirFlowRate > 0

        # calculate quantity for instance (doesn't exist as a method in api)
        if source_space_or_space_type.class.to_s == 'OpenStudio::Model::SpaceType'
          quantity = 0
          source_space_or_space_type.spaces.each do |space|
            if !space.isDesignSpecificationOutdoorAirDefaulted
              quantity += space.multiplier
            end
          end
        else
          quantity = source_space_or_space_type.multiplier
        end

        # can't normalize air flow rate, convert to air flow rate per floor area
        blended_oa.setOutdoorAirFlowperFloorArea(blended_oa.outdoorAirFlowperFloorArea + quantity * oa.outdoorAirFlowRate / collection_floor_area)
      end
      if oa.outdoorAirFlowAirChangesperHour > 0
        # floor area should be good approximation of area for multiplier
        blended_oa.setOutdoorAirFlowAirChangesperHour(blended_oa.outdoorAirFlowAirChangesperHour + oa.outdoorAirFlowAirChangesperHour * oa_floor_area_ratio)
      end
    end

    # note: water_use_equipment can't be assigned to a space type. Leave it as is, if assigned to space type
    # todo - if we use this measure with new geometry need to find a way to pull water use equipment loads into new model

    return instances_array
  end

  # sort building stories
  def sort_building_stories_and_get_min_multiplier(model)
    sorted_building_stories = {}
    # loop through stories
    model.getBuildingStorys.sort.each do |story|
      story_min_z = nil
      # loop through spaces in story.
      story.spaces.sort.each do |space|
        space_z_min = OsLib_Geometry.getSurfaceZValues(space.surfaces.to_a).min + space.zOrigin
        if story_min_z.nil? || (story_min_z > space_z_min)
          story_min_z = space_z_min
        end
      end
      sorted_building_stories[story] = story_min_z
    end

    return sorted_building_stories
  end

  # gather_envelope_data for envelope simplification
  def gather_envelope_data(runner, model)
    runner.registerInfo('Gathering envelope data.')

    # hash to contain envelope data
    envelope_data_hash = {}

    # used for overhang and party wall orientation catigorization
    facade_options = {
      'northEast' => 45,
      'southEast' => 125,
      'southWest' => 225,
      'northWest' => 315
    }

    # get building level inputs
    envelope_data_hash[:north_axis] = model.getBuilding.northAxis
    envelope_data_hash[:building_floor_area] = model.getBuilding.floorArea
    envelope_data_hash[:building_exterior_surface_area] = model.getBuilding.exteriorSurfaceArea
    envelope_data_hash[:building_exterior_wall_area] = model.getBuilding.exteriorWallArea
    envelope_data_hash[:building_exterior_roof_area] = envelope_data_hash[:building_exterior_surface_area] - envelope_data_hash[:building_exterior_wall_area]
    envelope_data_hash[:building_air_volume] = model.getBuilding.airVolume
    envelope_data_hash[:building_perimeter] = nil # will be applied for first story without ground walls

    # get bounding_box
    bounding_box = OpenStudio::BoundingBox.new
    model.getSpaces.sort.each do |space|
      space.surfaces.sort.each do |spaceSurface|
        bounding_box.addPoints(space.transformation * spaceSurface.vertices)
      end
    end
    min_x = bounding_box.minX.get
    min_y = bounding_box.minY.get
    min_z = bounding_box.minZ.get
    max_x = bounding_box.maxX.get
    max_y = bounding_box.maxY.get
    max_z = bounding_box.maxZ.get
    envelope_data_hash[:building_min_xyz] = [min_x, min_y, min_z]
    envelope_data_hash[:building_max_xyz] = [max_x, max_y, max_z]

    # add orientation specific wwr
    ext_surfaces_hash = OsLib_Geometry.getExteriorWindowAndWllAreaByOrientation(model, model.getSpaces.sort.to_a)
    envelope_data_hash[:building_wwr_n] = ext_surfaces_hash['northWindow'] / ext_surfaces_hash['northWall']
    envelope_data_hash[:building_wwr_s] = ext_surfaces_hash['southWindow'] / ext_surfaces_hash['southWall']
    envelope_data_hash[:building_wwr_e] = ext_surfaces_hash['eastWindow'] / ext_surfaces_hash['eastWall']
    envelope_data_hash[:building_wwr_w] = ext_surfaces_hash['westWindow'] / ext_surfaces_hash['westWall']
    envelope_data_hash[:stories] = {} # each entry will be hash with buildingStory as key and attributes has values
    envelope_data_hash[:space_types] = {} # each entry will be hash with spaceType as key and attributes has values

    # as rough estimate overhang area / glazing area should be close to projection factor assuming overhang is same width as windows
    # will only add building shading surfaces assoicated with a sub-surface.
    building_overhang_area_n = 0.0
    building_overhang_area_s = 0.0
    building_overhang_area_e = 0.0
    building_overhang_area_w = 0.0

    # loop through stories based on mine z height of surfaces.
    sorted_stories = sort_building_stories_and_get_min_multiplier(model).sort_by { |k, v| v }
    sorted_stories.each do |story, story_min_z|
      story_min_multiplier = nil
      story_footprint = nil
      story_multiplied_floor_area = OsLib_HelperMethods.getAreaOfSpacesInArray(model, story.spaces, 'floorArea')['totalArea']
      # goal of footprint calc is to count multiplier for hotel room on facade,but not to count what is intended as a story multiplier
      story_multiplied_exterior_surface_area = OsLib_HelperMethods.getAreaOfSpacesInArray(model, story.spaces, 'exteriorArea')['totalArea']
      story_multiplied_exterior_wall_area = OsLib_HelperMethods.getAreaOfSpacesInArray(model, story.spaces, 'exteriorWallArea')['totalArea']
      story_multiplied_exterior_roof_area = story_multiplied_exterior_surface_area - story_multiplied_exterior_wall_area
      story_has_ground_walls = []
      story_has_adiabatic_walls = []
      story_included_in_building_area = false # will be true if any spaces on story are inclued in building area
      story_max_z = nil

      # loop through spaces for story gathering information
      story.spaces.each do |space|
        # get min multiplier value
        multiplier = space.multiplier
        if story_min_multiplier.nil? || (story_min_multiplier > multiplier)
          story_min_multiplier = multiplier
        end

        # calculate footprint
        story_footprint = story_multiplied_floor_area / story_min_multiplier

        # see if part of floor area
        if space.partofTotalFloorArea
          story_included_in_building_area = true

          # add to space type ratio hash when space is included in building floor area
          if space.spaceType.is_initialized
            space_type = space.spaceType.get
            space_floor_area = space.floorArea * space.multiplier
            if envelope_data_hash[:space_types].key?(space_type)
              envelope_data_hash[:space_types][space_type][:floor_area] += space_floor_area
            else
              envelope_data_hash[:space_types][space_type] = {}
              envelope_data_hash[:space_types][space_type][:floor_area] = space_floor_area

              # make hash for heating and cooling setpoints
              envelope_data_hash[:space_types][space_type][:htg_setpoint] = {}
              envelope_data_hash[:space_types][space_type][:clg_setpoint] = {}

            end

            # add heating and cooling setpoints
            if space.thermalZone.is_initialized && space.thermalZone.get.thermostatSetpointDualSetpoint.is_initialized
              thermostat = space.thermalZone.get.thermostatSetpointDualSetpoint.get

              # log heating schedule
              if thermostat.heatingSetpointTemperatureSchedule.is_initialized
                htg_sch = thermostat.heatingSetpointTemperatureSchedule.get
                if envelope_data_hash[:space_types][space_type][:htg_setpoint].key?(htg_sch)
                  envelope_data_hash[:space_types][space_type][:htg_setpoint][htg_sch] += space_floor_area
                else
                  envelope_data_hash[:space_types][space_type][:htg_setpoint][htg_sch] = space_floor_area
                end
              else
                runner.registerWarning("#{space.thermalZone.get.name} containing #{space.name} doesn't have a heating setpoint schedule.")
              end

              # log cooling schedule
              if thermostat.coolingSetpointTemperatureSchedule.is_initialized
                clg_sch = thermostat.coolingSetpointTemperatureSchedule.get
                if envelope_data_hash[:space_types][space_type][:clg_setpoint].key?(clg_sch)
                  envelope_data_hash[:space_types][space_type][:clg_setpoint][clg_sch] += space_floor_area
                else
                  envelope_data_hash[:space_types][space_type][:clg_setpoint][clg_sch] = space_floor_area
                end
              else
                runner.registerWarning("#{space.thermalZone.get.name} containing #{space.name} doesn't have a heating setpoint schedule.")
              end

            else
              runner.registerWarning("#{space.name} either isn't in a thermal zone or doesn't have a thermostat assigned")
            end

          else
            runner.regsiterWarning("#{space.name} is included in the building floor area but isn't assigned a space type.")
          end

        end

        # check for walls with adiabatic and ground boundary condition
        space.surfaces.each do |surface|
          next if surface.surfaceType != 'Wall'
          if surface.outsideBoundaryCondition == 'Ground'
            story_has_ground_walls << surface
          elsif surface.outsideBoundaryCondition == 'Adiabatic'
            story_has_adiabatic_walls << surface
          end
        end

        # populate overhang values
        space.surfaces.each do |surface|
          surface.subSurfaces.each do |sub_surface|
            sub_surface.shadingSurfaceGroups.each do |shading_surface_group|
              shading_surface_group.shadingSurfaces.each do |shading_surface|
                absoluteAzimuth = OpenStudio.convert(sub_surface.azimuth, 'rad', 'deg').get + sub_surface.space.get.directionofRelativeNorth + model.getBuilding.northAxis
                absoluteAzimuth -= 360.0 until absoluteAzimuth < 360.0
                # add to hash based on orientation
                if (facade_options['northEast'] <= absoluteAzimuth) && (absoluteAzimuth < facade_options['southEast']) # East overhang
                  building_overhang_area_e += shading_surface.grossArea * space.multiplier
                elsif (facade_options['southEast'] <= absoluteAzimuth) && (absoluteAzimuth < facade_options['southWest']) # South overhang
                  building_overhang_area_s += shading_surface.grossArea * space.multiplier
                elsif (facade_options['southWest'] <= absoluteAzimuth) && (absoluteAzimuth < facade_options['northWest']) # West overhang
                  building_overhang_area_w += shading_surface.grossArea * space.multiplier
                else # North overhang
                  building_overhang_area_n += shading_surface.grossArea * space.multiplier
                end
              end
            end
          end
        end

        # get max z
        space_z_max = OsLib_Geometry.getSurfaceZValues(space.surfaces.to_a).max + space.zOrigin
        if story_max_z.nil? || (story_max_z > space_z_max)
          story_max_z = space_z_max
        end
      end

      # populate hash for story data
      envelope_data_hash[:stories][story] = {}
      envelope_data_hash[:stories][story][:story_min_height] = story_min_z
      envelope_data_hash[:stories][story][:story_max_height] = story_max_z
      envelope_data_hash[:stories][story][:story_min_multiplier] = story_min_multiplier
      envelope_data_hash[:stories][story][:story_has_ground_walls] = story_has_ground_walls
      envelope_data_hash[:stories][story][:story_has_adiabatic_walls] = story_has_adiabatic_walls
      envelope_data_hash[:stories][story][:story_included_in_building_area] = story_included_in_building_area
      envelope_data_hash[:stories][story][:story_footprint] = story_footprint
      envelope_data_hash[:stories][story][:story_multiplied_floor_area] = story_multiplied_floor_area
      envelope_data_hash[:stories][story][:story_exterior_surface_area] = story_multiplied_exterior_surface_area
      envelope_data_hash[:stories][story][:story_multiplied_exterior_wall_area] = story_multiplied_exterior_wall_area
      envelope_data_hash[:stories][story][:story_multiplied_exterior_roof_area] = story_multiplied_exterior_roof_area

      # get perimeter and adiabatic walls that appear to be party walls
      perimeter_and_party_walls = OsLib_Geometry.calculate_story_exterior_wall_perimeter(runner, story, story_min_multiplier, ['Outdoors', 'Ground', 'Adiabatic'], bounding_box)
      envelope_data_hash[:stories][story][:story_perimeter] = perimeter_and_party_walls[:perimeter]
      envelope_data_hash[:stories][story][:story_party_walls] = []
      east = false
      south = false
      west = false
      north = false
      perimeter_and_party_walls[:party_walls].each do |surface|
        absoluteAzimuth = OpenStudio.convert(surface.azimuth, 'rad', 'deg').get + surface.space.get.directionofRelativeNorth + model.getBuilding.northAxis
        absoluteAzimuth -= 360.0 until absoluteAzimuth < 360.0

        # add to hash based on orientation (initially added array of sourfaces, but swtiched to just true/false flag)
        if (facade_options['northEast'] <= absoluteAzimuth) && (absoluteAzimuth < facade_options['southEast']) # East party walls
          east = true
        elsif (facade_options['southEast'] <= absoluteAzimuth) && (absoluteAzimuth < facade_options['southWest']) # South party walls
          south = true
        elsif (facade_options['southWest'] <= absoluteAzimuth) && (absoluteAzimuth < facade_options['northWest']) # West party walls
          west = true
        else # North party walls
          north = true
        end
      end

      if east then envelope_data_hash[:stories][story][:story_party_walls] << 'east' end
      if south then envelope_data_hash[:stories][story][:story_party_walls] << 'south' end
      if west then envelope_data_hash[:stories][story][:story_party_walls] << 'west' end
      if north then envelope_data_hash[:stories][story][:story_party_walls] << 'north' end

      # store perimeter from first story that doesn't have ground walls
      if story_has_ground_walls.empty? && envelope_data_hash[:building_perimeter].nil?
        envelope_data_hash[:building_perimeter] = envelope_data_hash[:stories][story][:story_perimeter]
        runner.registerInfo(" * #{story.name} is the first above grade story and will be used for the building perimeter.")
      end
    end

    envelope_data_hash[:building_overhang_proj_factor_n] = building_overhang_area_n / ext_surfaces_hash['northWindow']
    envelope_data_hash[:building_overhang_proj_factor_s] = building_overhang_area_s / ext_surfaces_hash['southWindow']
    envelope_data_hash[:building_overhang_proj_factor_e] = building_overhang_area_e / ext_surfaces_hash['eastWindow']
    envelope_data_hash[:building_overhang_proj_factor_w] = building_overhang_area_w / ext_surfaces_hash['westWindow']

    # warn for spaces that are not on a story (in future could infer stories for these)
    model.getSpaces.sort.each do |space|
      if !space.buildingStory.is_initialized
        runner.registerWarning("#{space.name} is not on a building story, may have unexpected results.")
      end
    end

    return envelope_data_hash
  end
end