class BinData::Array

def [](*args)
  if args.length == 1 and ::Integer === args[0]
    # extend array automatically
    while args[0] >= elements.length
      append_new_element
    end
  end
  data = elements[*args]
  if args.length > 1 or ::Range === args[0]
    data.collect { |el| (el && el.single_value?) ? el.value : el }
  else
    (data && data.single_value?) ? data.value : data
  end
end

def []=(index, value)
  # extend array automatically
  while index >= elements.length
    append_new_element
  end
  obj = elements[index]
  unless obj.single_value?
    # TODO: allow setting objects, not just values
    raise NoMethodError, "undefined method `[]=' for #{self}", caller
  end
  obj.value = value
end

def _do_num_bytes(index)
  if index.nil?
    (elements.inject(0) { |sum, f| sum + f.do_num_bytes }).ceil
  else
    elements[index].do_num_bytes
  end
end

def _do_read(io)
  if has_param?(:initial_length)
    elements.each { |f| f.do_read(io) }
  elsif has_param?(:read_until)
    if no_eval_param(:read_until) == :eof
      @element_list = nil
      loop do
        element = append_new_element
        begin
          element.do_read(io)
        rescue
          @element_list.pop
          break
        end
      end
    else
      @element_list = nil
      loop do
        element = append_new_element
        element.do_read(io)
        variables = { :index => self.length - 1, :element => self.last,
                      :array => self }
        finished = eval_param(:read_until, variables)
        break if finished
      end
    end
  end
end

def _do_write(io)
  elements.each { |f| f.do_write(io) }
end

def _snapshot
  elements.collect { |e| e.snapshot }
end

def append(value = nil)
  # TODO: deprecate #append as it can be replaced with #push
  append_new_element
  self[-1] = value unless value.nil?
  self.last
end

def append_new_element
  # ensure @element_list is initialised
  elements()
  element = @element_klass.new(@element_params, self)
  @element_list << element
  element
end

def clear(index = nil)
  if @element_list.nil?
    # do nothing as the array is already clear
  elsif index.nil?
    @element_list = nil
  elsif index < elements.length
    elements[index].clear
  end
end

def clear?(index = nil)
  if @element_list.nil?
    true
  elsif index.nil?
    elements.each { |f| return false if not f.clear? }
    true
  else
    (index < elements.length) ? elements[index].clear? : true
  end
end

def done_read
  elements.each { |f| f.done_read }
end

def each
  elements.each do |el|
    yield(el.single_value? ? el.value : el)
  end
end

def elements
  if @element_list.nil?
    @element_list = []
    if has_param?(:initial_length)
      # create the desired number of instances
      eval_param(:initial_length).times do
        append_new_element
      end
    end
  end
  @element_list
end

def empty?
  length.zero?
end

def first(n = nil)
  if n.nil? and elements.empty?
    # explicitly return nil as arrays grow automatically
    nil
  elsif n.nil?
    self[0]
  else
    self[0, n]
  end
end

def index(obj)
  # TODO handle single values
  elements.index(obj)
end

def initialize(params = {}, parent = nil)
  super(params, parent)
  klass, el_params = no_eval_param(:type)
  @element_list    = nil
  @element_klass   = klass
  @element_params  = el_params
end

def last(n = nil)
  if n.nil?
    self[-1]
  else
    n = length if n > length
    self[-n, n]
  end
end

def length
  elements.length
end

def push(*args)
  args.each do |arg|
    if @element_klass == arg.class
      # TODO: need to modify arg.env to add_variable(:index) and
      # to link arg.env to self.env
      elements.push(arg)
    else
      append(arg)
    end
  end
  self
end

def sanitize_parameters!(sanitizer, params)
  unless params.has_key?(:initial_length) or params.has_key?(:read_until)
    # ensure one of :initial_length and :read_until exists
    params[:initial_length] = 0
  end
  if params.has_key?(:read_length)
    warn ":read_length is not used with arrays.  You probably want to change this to :initial_length"
  end
  if params.has_key?(:type)
    type, el_params = params[:type]
    klass = sanitizer.lookup_klass(type)
    sanitized_params = sanitizer.sanitize_params(klass, el_params)
    params[:type] = [klass, sanitized_params]
  end
  super(sanitizer, params)
end

def single_value?
  return false
end

def to_ary
  snapshot
end