class Fugit::Nat::Slot

def a; [ data0, data1 ]; end

def append(slot)
  @_data0, @_data1 = conflate(0, slot), conflate(1, slot)
  @opts.clear
  self
end

def conflate(index, slot)
  a, b = index == 0 ? [ @_data0, slot._data0 ] : [ @_data1, slot._data1 ]
  return a if b == nil
  return b if a == nil
  if ra = (index == 0 && slot.strong == 1 && hour_range)
    h0, h1 = ra[0], ra[1] - 1; return h0 == h1 ? h0 : "#{h0}-#{h1}"
  elsif rb = (index == 0 && strong == 1 && slot.hour_range)
    h0, h1 = rb[0], rb[1] - 1; return h0 == h1 ? h0 : "#{h0}-#{h1}"
  end
  return a if strong == index || strong == true
  return b if slot.strong == index || slot.strong == true
  return a if slot.weak == index || slot.weak == true
  return b if weak == index || weak == true
  return [ '*' ] if a == '*' && b == '*'
  to_a(a).concat(to_a(b))
end

def data0; @data0 ||= Array(@_data0); end

def data1; @data1 ||= Array(@_data1); end

def graded?; weak || strong; end

def hour_range
  m = (key == :hm && @_data1 == 0 && @_data0.match(/\A(\d+)-(\d+)\z/))
  m ? [ m[1].to_i, m[2].to_i ] : nil
end

def initialize(key, d0, d1=nil, opts=nil)
  d1, opts = d1.is_a?(Symbol) ? [ nil, d1 ] : [ d1, opts ]
  @key, @_data0, @_data1 = key, d0, d1
  @opts = (opts.is_a?(Symbol) ? { opts => true } : opts) || {}
end

def inspect
  a = [ @key, @_data0 ]
  a << @_data1 if @_data1 != nil
  a << @opts if @opts && @opts.keys.any?
  "(slot #{a.collect(&:inspect).join(' ')})"
end

def strong; @opts[:strong]; end

def to_a(x)
  return [] if x == '*'
  Array(x)
end

def weak; @opts[:weak]; end