# encoding: ascii-8bit

# Copyright 2022 Ball Aerospace & Technologies Corp.
# All Rights Reserved.
#
# This program is free software; you can modify and/or redistribute it
# under the terms of the GNU Affero General Public License
# as published by the Free Software Foundation; version 3 with
# attribution addendums as found in the LICENSE.txt
#
# This program 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 Affero General Public License for more details.

# Modified by OpenC3, Inc.
# All changes Copyright 2022, OpenC3, Inc.
# All Rights Reserved
#
# This file may also be used under the terms of a commercial license
# if purchased from OpenC3, Inc.

require 'nokogiri'
require 'ostruct'

module OpenC3
  class XtceParser
    attr_accessor :current_target_name

    # Processes a XTCE formatted OpenC3 configuration file
    #
    # @param commands [Hash<String=>Packet>] Hash of all the command packets
    #   keyed by the packet name.
    # @param telemetry [Hash<String=>Packet>] Hash of all the telemetry packets
    #   keyed by the packet name.
    # @param warnings [Array<String>] Array of strings listing all the warnings
    #   that were created while parsing the configuration
    # @param filename [String] The name of the configuration file
    # @param target_name [String] Override the target name found in the XTCE file
    def self.process(commands, telemetry, warnings, filename, target_name = nil)
      XtceParser.new(commands, telemetry, warnings, filename, target_name)
    end

    def self.reverse_packet_order(target_name, cmd_or_tlm_hash)
      if cmd_or_tlm_hash[target_name]
        packets = []
        names_to_remove = []
        cmd_or_tlm_hash[target_name].each do |packet_name, packet|
          packets << packet
          names_to_remove << packet_name
        end
        cmd_or_tlm_hash[target_name].length.times do |i|
          cmd_or_tlm_hash[target_name].delete(names_to_remove[i])
        end
        packets.reverse_each do |packet|
          cmd_or_tlm_hash[target_name][packet.packet_name] = packet
        end
      end
    end

    private

    def initialize(commands, telemetry, warnings, filename, target_name = nil)
      reset_processing_variables()
      @commands = commands
      @telemetry = telemetry
      @warnings = warnings
      @current_packet = nil
      parse(filename, target_name)
    end

    def parse(filename, target_name)
      # Fortify complains about Path Manipulation here
      # We have previously validated the file is a .xtce file in packet_config
      # The file is opened read-only and then immediately parsed by Nokogiri
      doc = File.open(filename) { |f| Nokogiri::XML(f, nil, nil, Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS | Nokogiri::XML::ParseOptions::HUGE) }
      # Determine the @current_target_name
      xtce_process_element(doc.root)
      @current_target_name = target_name if target_name
      doc.root.children.each do |child|
        xtce_recurse_element(child) do |element|
          xtce_process_element(element)
        end
      end
      finish_packet()

      # Remove abstract
      if @commands[@current_target_name]
        @commands[@current_target_name].delete_if { |packet_name, packet| packet.abstract }
      end
      if @telemetry[@current_target_name]
        @telemetry[@current_target_name].delete_if { |packet_name, packet| packet.abstract }
      end

      # Reverse order of packets for the target so ids work correctly
      XtceParser.reverse_packet_order(@current_target_name, @commands)
      XtceParser.reverse_packet_order(@current_target_name, @telemetry)

      reset_processing_variables()
    end

    # Add current packet into hash if it exists
    def finish_packet
      if @current_packet
        @warnings += @current_packet.check_bit_offsets
        set_packet_endianness()
        if @current_cmd_or_tlm == PacketConfig::COMMAND
          PacketParser.check_item_data_types(@current_packet)
          @commands[@current_packet.target_name][@current_packet.packet_name] = @current_packet
        else
          @telemetry[@current_packet.target_name][@current_packet.packet_name] = @current_packet
        end
        @current_packet = nil
      end
    end

    def set_packet_endianness
      item_endianness = @current_packet.sorted_items.collect do |item|
        # Ignore OpenC3 reserved items
        next if Packet::RESERVED_ITEM_NAMES.include?(item.name)

        # Strings and Blocks endianness don't matter so ignore them
        item.endianness if item.data_type != :STRING && item.data_type != :BLOCK
      end
      # Compact to get rid of nils from skipping Strings and Blocks
      # Uniq to get rid of duplicates which results in an array of 1 or 2 items
      item_endianness = item_endianness.compact.uniq
      if item_endianness.length == 1 # All items have the same endianness
        # default_endianness is read_only since it affects how items are added
        # thus we have to use instance_variable_set here to override it
        @current_packet.instance_variable_set(:@default_endianness, item_endianness[0])
      end
    end

    def reset_processing_variables
      @current_target_name = nil
      @current_cmd_or_tlm = nil
      @current_type = nil
      @current_meta_command = nil
      @current_parameter = nil
      @current_argument = nil
      @parameter_types = {}
      @argument_types = {}
      @parameters = {}
      @arguments = {}
      @containers = {}
    end

    def create_new_type(element)
      current_type = OpenStruct.new
      element.attributes.each do |att_name, att|
        current_type[att.name] = att.value
      end
      if /Argument/.match?(element.name)
        @argument_types[element["name"]] = current_type
      else
        @parameter_types[element["name"]] = current_type
      end
      current_type
    end

    XTCE_IGNORED_ELEMENTS = ['text', 'AliasSet', 'Alias', 'Header']

    def xtce_process_element(element)
      if XTCE_IGNORED_ELEMENTS.include?(element.name)
        return false
      end

      case element.name
      when 'SpaceSystem'
        @current_target_name = element["name"].to_s.upcase

      when 'TelemetryMetaData'
        finish_packet()
        @current_cmd_or_tlm = PacketConfig::TELEMETRY

      when 'CommandMetaData'
        finish_packet()
        @current_cmd_or_tlm = PacketConfig::COMMAND

      when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet',
        'EntryList', 'DefaultCalibrator', 'DefaultAlarm', 'RestrictionCriteria',
        'ComparisonList', 'MetaCommandSet', 'ArgumentTypeSet', 'ArgumentList',
        'ArgumentAssignmentList', 'LocationInContainerInBits', 'ReferenceTime',
        'AncillaryDataSet', 'AncillaryData'
        # Do Nothing

      when 'ErrorDetectCorrect'
        # TODO: Setup an algorithm to calculate the CRC
        exponents = []
        xtce_recurse_element(element) do |crc_element|
          if crc_element.name == 'CRC'
            xtce_recurse_element(crc_element) do |poly_element|
              if poly_element['Polynomial']
                xtce_recurse_element(poly_element) do |term_element|
                  if term_element['Term']
                    exponents << term_element['exponent'].to_i
                  end
                  true
                end
              end
              true
            end
          end
          true
        end
        @current_type.xtce_encoding = 'IntegerDataEncoding'
        @current_type.signed = 'false'
        return false # Already recursed

      when 'EnumeratedParameterType', 'EnumeratedArgumentType',
        'IntegerParameterType', 'IntegerArgumentType',
        'FloatParameterType', 'FloatArgumentType',
        'StringParameterType', 'StringArgumentType',
        'BinaryParameterType', 'BinaryArgumentType',
        'BooleanParameterType', 'BooleanArgumentType',
        'AbsoluteTimeParameterType', 'AbsoluteTimeArgumentType',
        'RelativeTimeParameterType', 'RelativeTimeArgumentType'
        @current_type = create_new_type(element)
        @current_type.endianness = :BIG_ENDIAN

        case element.name
        when 'EnumeratedParameterType', 'EnumeratedArgumentType'
          @current_type.xtce_encoding = 'IntegerDataEncoding'
          @current_type.sizeInBits = 8 # This is undocumented but appears to be the design
        when 'IntegerParameterType', 'IntegerArgumentType'
          @current_type.xtce_encoding = 'IntegerDataEncoding'
          @current_type.sizeInBits = 32
        when 'FloatParameterType', 'FloatArgumentType'
          @current_type.xtce_encoding = 'FloatDataEncoding'
          @current_type.sizeInBits = 32
        when 'StringParameterType', 'StringArgumentType'
          @current_type.xtce_encoding = 'StringDataEncoding'
        when 'BinaryParameterType', 'BinaryArgumentType'
          @current_type.xtce_encoding = 'BinaryDataEncoding'
          @current_type.sizeInBits = 8 # This is undocumented but appears to be the design
        when 'BooleanParameterType', 'BooleanArgumentType'
          @current_type.xtce_encoding = 'StringDataEncoding'
          @current_type.sizeInBits = 8 # This is undocumented but appears to be the design
          @current_type.states ||= {}
          if element.attributes['zeroStringValue'] && element.attributes['oneStringValue']
            @current_type.states[element.attributes['zeroStringValue'].value] = 0
            @current_type.states[element.attributes['oneStringValue'].value] = 1
          else
            @current_type.states['FALSE'] = 0
            @current_type.states['TRUE'] = 1
          end
        # No defaults for the time types
        # when 'AbsoluteTimeParameterType', 'AbsoluteTimeArgumentType',
        # when'RelativeTimeParameterType', 'RelativeTimeArgumentType'
        end

      when 'ArrayParameterType', 'ArrayArgumentType'
        @current_type = create_new_type(element)

      when 'ByteOrderList'
        byte_list = []
        xtce_recurse_element(element) do |block_element|
          if block_element.name == 'Byte'
            if block_element['byteSignificance']
              byte_list << block_element['byteSignificance'].to_i
            end
          end
          true
        end
        if byte_list[0] == 0
          # Little endian will always start with 0 - Its ok if a single byte item is marked little endian
          @current_type.endianness = :LITTLE_ENDIAN
        end

        # Verify ordering of byte list is supported
        if byte_list[0] >= byte_list[-1]
          ordered_byte_list = byte_list.reverse
        else
          ordered_byte_list = byte_list.clone
        end
        if ordered_byte_list[0] != 0
          msg = "Invalid ByteOrderList detected: #{byte_list.join(", ")}"
          Logger.instance.warn msg
          @warnings << msg
        else
          previous_byte = nil
          ordered_byte_list.each do |byte|
            if previous_byte
              if byte - previous_byte != 1
                msg = "Invalid ByteOrderList detected: #{byte_list.join(", ")}"
                Logger.instance.warn msg
                @warnings << msg
                break
              end
            end
            previous_byte = byte
          end
        end

        return false # Already recursed

      when 'SizeInBits'
        xtce_recurse_element(element) do |block_element|
          if block_element.name == 'FixedValue'
            @current_type.sizeInBits = Integer(block_element.text)
            false
          else
            true
          end
        end
        return false # Already recursed

      when 'UnitSet'
        xtce_recurse_element(element) do |block_element|
          if block_element.name == 'Unit'
            units = block_element.text.to_s
            description = block_element['description'].to_s
            description = units if description.empty?
            units = description if units.empty?

            @current_type.units ||= ''
            if @current_type.units.empty?
              @current_type.units << units
            else
              @current_type.units << ('/' + units)
            end
            @current_type.units << "^#{block_element['power']}" if block_element['power']

            @current_type.units_full ||= ''
            if @current_type.units_full.empty?
              @current_type.units_full << description
            else
              @current_type.units_full << ('/' + description)
            end
          end
          true
        end
        return false # Already recursed

      when 'PolynomialCalibrator'
        xtce_recurse_element(element) do |block_element|
          if block_element.name == 'Term'
            exponent = Float(block_element['exponent']).to_i
            @current_type.conversion ||= PolynomialConversion.new()
            @current_type.conversion.coeffs[exponent] = Float(block_element['coefficient'])
            @current_type.conversion.coeffs.each_with_index do |value, index|
              @current_type.conversion.coeffs[index] = 0.0 if value.nil?
            end
          end
          true
        end
        return false # Already recursed

      when 'StaticAlarmRanges'
        xtce_recurse_element(element) do |block_element|
          if block_element.name == 'WarningRange'
            @current_type.limits ||= [0.0, 0.0, 0.0, 0.0]
            @current_type.limits[1] = Float(block_element['minInclusive']) if block_element['minInclusive']
            @current_type.limits[2] = Float(block_element['maxInclusive']) if block_element['maxInclusive']
          elsif block_element.name == 'CriticalRange'
            @current_type.limits ||= [0.0, 0.0, 0.0, 0.0]
            @current_type.limits[0] = Float(block_element['minInclusive']) if block_element['minInclusive']
            @current_type.limits[3] = Float(block_element['maxInclusive']) if block_element['maxInclusive']
          end
          true
        end
        return false # Already recursed

      when "ValidRange"
        @current_type.minInclusive = element['minInclusive']
        @current_type.maxInclusive = element['maxInclusive']

      when 'Enumeration'
        @current_type.states ||= {}
        @current_type.states[element['label']] = Integer(element['value'])

      when 'Encoding'
        if element.attributes['units']
          @current_type.units_full = element.attributes['units'].value
          # Could do a better job mapping units to abbreviations
          @current_type.units = element.attributes['units'].value[0]
        end
        # TODO: Not sure if this is correct
        # if @current_type.attributes['scale'] || @current_type.attributes['offset']
        #   @current_type.conversion ||= PolynomialConversion.new()
        #   if @current_type.attributes['offset']
        #     @current_type.conversion.coeffs[0] = @current_type.attributes['offset']
        #   end
        #   if @current_type.attributes['scale']
        #     @current_type.conversion.coeffs[1] = @current_type.attributes['scale']
        #   end
        # end

      when 'Epoch'
        # TODO: How to handle this ... it affects the conversion applied

      when 'IntegerDataEncoding', 'FloatDataEncoding', 'StringDataEncoding', 'BinaryDataEncoding'
        @current_type.xtce_encoding = element.name
        element.attributes.each do |att_name, att|
          @current_type[att.name] = att.value
        end
        @current_type.sizeInBits = 8 unless element.attributes['sizeInBits']

        case element.attributes['byteOrder'].to_s
        when 'mostSignificantByteFirst'
          @current_type.endianness = :BIG_ENDIAN
        when 'leastSignificantByteFirst'
          @current_type.endianness = :LITTLE_ENDIAN
        end

        # Ensure if the encoding is a string we convert state values to strings
        if @current_type.xtce_encoding == 'StringDataEncoding' && @current_type.states
          @current_type.states.transform_values!(&:to_s)
        end

      when 'Parameter'
        @current_parameter = OpenStruct.new
        element.attributes.each do |att_name, att|
          @current_parameter[att.name] = att.value
        end
        @parameters[element["name"]] = @current_parameter

      when 'Argument'
        @current_argument = OpenStruct.new
        element.attributes.each do |att_name, att|
          @current_argument[att.name] = att.value
        end
        @arguments[element["name"]] = @current_argument

      when 'ParameterProperties'
        element.attributes.each do |att_name, att|
          @current_parameter[att.name] = att.value
        end

      when "SequenceContainer"
        finish_packet()
        @current_packet = Packet.new(@current_target_name, element['name'], :BIG_ENDIAN, element['shortDescription'])
        @current_packet.abstract = ConfigParser.handle_true_false_nil(element['abstract'])
        @containers[element['name']] = @current_packet
        PacketParser.finish_create_telemetry(@current_packet, @telemetry, {}, @warnings)

        # Need to check for a BaseContainer now because if we hit it later it will be too late
        xtce_handle_base_container('BaseContainer', element)

      when 'LongDescription'
        if @current_packet && !@current_packet.description
          @current_packet.description = element.text
        end

      when 'ParameterRefEntry', 'ArgumentRefEntry', 'ArrayParameterRefEntry', 'ArrayArgumentRefEntry'
        process_ref_entry(element)
        return false # Already recursed

      when 'ContainerRefEntry'
        xtce_handle_base_container('ContainerRefEntry', element)

      when 'BaseContainer'
        # Handled in SequenceContainer/CommandContainer

      when 'BaseMetaCommand'
        # Handled in MetaCommand

      when 'Comparison'
        # Need to set ID value for item
        item = @current_packet.get_item(element['parameterRef'])
        item.id_value = Integer(element['value'])
        if @current_cmd_or_tlm == PacketConfig::COMMAND
          item.default = item.id_value
        end
        @current_packet.update_id_items(item)

      when 'MetaCommand'
        finish_packet()
        @current_packet = Packet.new(@current_target_name, element['name'], :BIG_ENDIAN, element['shortDescription'])
        @current_packet.abstract = ConfigParser.handle_true_false_nil(element['abstract'])
        PacketParser.finish_create_command(@current_packet, @commands, @warnings)

        # Need to check for a BaseContainer now because if we hit it later it will be too late
        xtce_handle_base_container('BaseMetaCommand', element)

      when 'CommandContainer'
        @containers[element['name']] = @current_packet

        # Need to check for a BaseContainer now because if we hit it later it will be too late
        xtce_handle_base_container('BaseContainer', element)

      when 'ArgumentAssignment'
        # Need to set ID value for item
        item = @current_packet.get_item(element['argumentName'])
        value = element['argumentValue']
        if item.states && item.states[value.to_s.upcase]
          item.id_value = item.states[value.to_s.upcase]
          item.default = item.id_value
        else
          item.id_value = Integer(value)
          item.default = item.id_value
        end
        @current_packet.update_id_items(item)

      else
        puts "  Ignoring Unknown: <#{element.name}>"

      end # case element.name

      return true # Recurse further
    end

    def process_ref_entry(element)
      reference_location, bit_offset = xtce_handle_location_in_container_in_bits(element)
      object, type, data_type, array_type = get_object_types(element)
      bit_size = Integer(type.sizeInBits)
      if array_type
        array_bit_size = process_array_type(element, bit_size)
      else
        array_bit_size = nil # in define_item, nil indicates the item is not an array
      end

      if bit_offset
        case reference_location
        when 'containerStart'
          item = @current_packet.define_item(object.name, bit_offset, bit_size, data_type, array_bit_size, type.endianness) # overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
        when 'containerEnd'
          item = @current_packet.define_item(object.name, -bit_offset, bit_size, data_type, array_bit_size, type.endianness) # overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
        when 'previousEntry', nil
          item = @current_packet.define_item(object.name, @current_packet.length + bit_offset, bit_size, data_type, array_bit_size, type.endianness) # overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
        when 'nextEntry'
          raise 'nextEntry is not supported'
        end
      else
        item = @current_packet.append_item(object.name, bit_size, data_type, array_bit_size, type.endianness) # overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
      end

      item.description = type.shortDescription if type.shortDescription
      item.states = type.states if type.states
      set_units(item, type)
      set_conversion(item, type, data_type)
      set_min_max_default(item, type, data_type)
      set_limits(item, type)
    end

    def get_object_types(element)
      array_type = nil
      if /Parameter/.match?(element.name)
        # Look up the parameter and parameter type
        parameter = @parameters[element['parameterRef']]
        raise "parameterRef #{element['parameterRef']} not found" unless parameter

        parameter_type = @parameter_types[parameter.parameterTypeRef]
        raise "parameterTypeRef #{parameter.parameterTypeRef} not found" unless parameter_type

        if element.name == 'ArrayParameterRefEntry'
          array_type = parameter_type
          parameter_type = @parameter_types[array_type.arrayTypeRef]
          raise "arrayTypeRef #{parameter.arrayTypeRef} not found" unless parameter_type
        end
        refName = 'parameterRef'
        object = parameter
        type = parameter_type
      else
        # Look up the argument and argument type
        if element.name == 'ArrayArgumentRefEntry'
          # Requiring parameterRef for argument arrays appears to be a defect in the schema
          argument = @arguments[element['parameterRef']]
          raise "parameterRef #{element['parameterRef']} not found" unless argument

          argument_type = @argument_types[argument.argumentTypeRef]
          raise "argumentTypeRef #{argument.argumentTypeRef} not found" unless argument_type

          array_type = argument_type
          argument_type = @argument_types[array_type.arrayTypeRef]
          raise "arrayTypeRef #{array_type.arrayTypeRef} not found" unless argument_type

          refName = 'parameterRef'
        else
          argument = @arguments[element['argumentRef']]
          raise "argumentRef #{element['argumentRef']} not found" unless argument

          argument_type = @argument_types[argument.argumentTypeRef]
          raise "argumentTypeRef #{argument.argumentTypeRef} not found" unless argument_type

          refName = 'argumentRef'
        end
        object = argument
        type = argument_type
      end

      data_type = get_data_type(type)
      raise "Referenced Parameter/Argument has no xtce_encoding: #{element[refName]}" unless data_type

      return [object, type, data_type, array_type]
    end

    def process_array_type(element, bit_size)
      array_num_items = 1
      # Need to determine dimensions
      xtce_recurse_element(element) do |block_element|
        if block_element.name == 'Dimension'
          starting_index = 0
          ending_index = 0
          block_element.children.each do |child_element|
            if child_element.name == 'StartingIndex'
              child_element.children.each do |child_element2|
                if child_element2.name == 'FixedValue'
                  starting_index = child_element2.text.to_i
                end
              end
            elsif child_element.name == 'EndingIndex'
              child_element.children.each do |child_element2|
                if child_element2.name == 'FixedValue'
                  ending_index = child_element2.text.to_i
                end
              end
              array_num_items *= ((ending_index - starting_index).abs + 1)
            end
            false # Don't recurse again
          end
          false # Don't recurse again
        else
          true # Keep recursing
        end
      end
      array_num_items * bit_size
    end

    def get_data_type(type)
      data_type = nil
      case type.xtce_encoding
      when 'IntegerDataEncoding'
        if type.signed == 'false' || type.encoding == 'unsigned'
          data_type = :UINT
        else
          data_type = :INT
        end
      when 'FloatDataEncoding'
        data_type = :FLOAT
      when 'StringDataEncoding'
        data_type = :STRING
      when 'BinaryDataEncoding'
        data_type = :BLOCK
      end
      data_type
    end

    def set_units(item, type)
      if type.units && type.units_full
        item.units = type.units
        item.units_full = type.units_full
      end
    end

    def set_conversion(item, type, data_type)
      if type.conversion && type.conversion.class == PolynomialConversion
        if @current_cmd_or_tlm == PacketConfig::COMMAND
          item.write_conversion = type.conversion
        else
          item.read_conversion = type.conversion
        end
      end
    end

    def set_min_max_default(item, type, data_type)
      return unless @current_cmd_or_tlm == PacketConfig::COMMAND

      # Need to set min, max, and default
      if data_type == :INT || data_type == :UINT
        if data_type == :INT
          item.range = (-(2**(Integer(type.sizeInBits) - 1)))..((2**(Integer(type.sizeInBits) - 1)) - 1)
        else
          item.range = 0..((2**Integer(type.sizeInBits)) - 1)
        end
        if type.minInclusive && type.maxInclusive
          item.range = Integer(type.minInclusive)..Integer(type.maxInclusive)
        end
        if item.array_size
          item.default = []
        else
          item.default = 0
          if item.states && item.states[type.initialValue.to_s.upcase]
            item.default = Integer(item.states[type.initialValue.to_s.upcase])
          else
            item.default = Integer(type.initialValue) if type.initialValue
          end
        end
      elsif data_type == :FLOAT
        if Integer(type.sizeInBits) == 32
          item.range = -3.402823e38..3.402823e38
        else
          item.range = -Float::MAX..Float::MAX
        end
        if type.minInclusive && type.maxInclusive
          item.range = Float(type.minInclusive)..Float(type.maxInclusive)
        end
        if item.array_size
          item.default = []
        else
          item.default = 0.0
          item.default = Float(type.initialValue) if type.initialValue
        end
      elsif data_type == :STRING || data_type == :BLOCK
        if item.array_size
          item.default = []
        else
          if type.initialValue
            if type.initialValue.upcase.start_with?("0X")
              item.default = type.initialValue.hex_to_byte_string
            else
              # Strip quotes from strings
              if type.initialValue[0] == '"' && type.initialValue[-1] == '"'
                item.default = type.initialValue[1..-2]
              else
                item.default = type.initialValue
              end
            end
          else
            item.default = ''
          end
        end
      end
    end

    def set_limits(item, type)
      return unless @current_cmd_or_tlm == PacketConfig::TELEMETRY

      if type.limits
        item.limits.enabled = true
        values = {}
        values[:DEFAULT] = type.limits
        item.limits.values = values
      end
    end

    def xtce_format_attributes(element)
      string = ''
      element.attributes.each do |att_name, att|
        string << "#{att.name}:#{att.value} "
      end
      if string.length > 0
        string = '( ' + string + ')'
      end
      return string
    end

    def xtce_recurse_element(element, &block)
      return unless yield(element)

      element.children.each do |child_element|
        xtce_recurse_element(child_element, &block)
      end
    end

    def xtce_handle_base_container(base_name, element)
      if element.name == base_name
        # Need to add BaseContainer items to current_packet
        # Lookup the base packet
        if base_name == 'BaseMetaCommand'
          base_packet = @commands[@current_packet.target_name][element['metaCommandRef'].to_s.upcase]
        else
          base_packet = @containers[element['containerRef']]
        end
        if base_packet
          count = 0
          base_packet.sorted_items.each do |item|
            unless ['PACKET_TIMESECONDS', 'PACKET_TIMEFORMATTED', 'RECEIVED_TIMESECONDS', 'RECEIVED_TIMEFORMATTED', 'RECEIVED_COUNT'].include?(item.name)
              begin
                @current_packet.get_item(item.name)
              rescue
                # Item hasn't already been added so define it
                @current_packet.define(item.clone)
                count += 1
              end
            end
          end
          return
        else
          if base_name == 'BaseMetaCommand'
            raise "Unknown #{base_name}: #{element['metaCommandRef']}"
          else
            raise "Unknown #{base_name}: #{element['containerRef']}"
          end
        end
      end
      element.children.each do |child_element|
        xtce_handle_base_container(base_name, child_element)
      end
    end

    def xtce_handle_location_in_container_in_bits(element)
      element.children.each do |child_element|
        if child_element.name == 'LocationInContainerInBits'
          child_element.children.each do |child_element2|
            if child_element2.name == 'FixedValue'
              return [child_element['referenceLocation'], Integer(child_element2.text)]
            end
          end
        end
      end
      return [nil, nil]
    end
  end
end
