module URITemplate

# File lib/uri_template.rb, line 166
def self.apply(a, method, b, *args)
  a,b,_,_ = self.coerce(a,b)
  a.send(method,b,*args)
end

# File lib/uri_template.rb, line 130
def self.coerce(a,b)
  if a.kind_of? URITemplate
    if a.class == b.class
      return [a,b,false,false]
    end
    b_as_a = a.class.try_convert(b)
    if b_as_a
      return [a,b_as_a,false,true]
    end
  end
  if b.kind_of? URITemplate
    a_as_b = b.class.try_convert(a)
    if a_as_b
      return [a_as_b, b, true, false]
    end
  end
  bc = self.try_convert(b)
  if bc.kind_of? URITemplate
    a_as_b = bc.class.try_convert(a)
    if a_as_b
      return [a_as_b, bc, true, true]
    end
  end
  raise ArgumentError, "Expected at least on URITemplate, but got #{a.inspect} and #{b.inspect}" unless a.kind_of? URITemplate or b.kind_of? URITemplate
  raise ArgumentError, "Cannot coerce #{a.inspect} and #{b.inspect} into a common representation."
end

# File lib/uri_template.rb, line 172
  def self.coerce_first_arg(meth)
    alias_method( (meth.to_s + '_without_coercion').to_sym , meth )
    class_eval(<<-RUBY)
def #{meth}(other, *args, &block)
  this, other, this_converted, _ = URITemplate.coerce( self, other )
  if this_converted
    return this.#{meth}(other,*args, &block)
  end
  return #{meth}_without_coercion(other,*args, &block)
end
RUBY
  end

# File lib/uri_template.rb, line 117
def self.new(*args)
  klass, rest = resolve_class(*args)
  return klass.new(*rest)
end

# File lib/uri_template.rb, line 99
def self.resolve_class(*args)
  symbols, rest = args.partition{|x| x.kind_of? Symbol }
  version = symbols.fetch(0, :default)
  raise ArgumentError, "Unknown template version #{version.inspect}, defined versions: #{VERSIONS.keys.inspect}" unless VERSIONS.key?(version)
  return self.const_get(VERSIONS[version]), rest
end

# File lib/uri_template.rb, line 383
def concat(other)
  if other.host? or other.scheme?
    raise ArgumentError, "Expected to receive a relative template but got an absoulte one: #{other.inspect}. If you think this is a bug, please report it."
  end

  return self if other.tokens.none?
  return other if self.tokens.none?
  return self.class.new( self.to_s + other.to_s )
end

# File lib/uri_template.rb, line 330
def eq(other)
  return self.pattern == other.pattern
end

# File lib/uri_template.rb, line 207
def expand(variables = {})
  variables = normalize_variables(variables)
  tokens.map{|part|
    part.expand(variables)
  }.join
end

# File lib/uri_template.rb, line 222
def expand_partial(variables = {})
  variables = normalize_variables(variables)
  self.class.new(tokens.map{|part|
    part.expand_partial(variables)
  }.flatten(1))
end

# File lib/uri_template.rb, line 299
def host?
  return scheme_and_host[1]
end

# File lib/uri_template.rb, line 350
def path_concat(other)
  if other.host? or other.scheme?
    raise ArgumentError, "Expected to receive a relative template but got an absoulte one: #{other.inspect}. If you think this is a bug, please report it."
  end

  return self if other.tokens.none?
  return other if self.tokens.none?

  tail = self.tokens.last
  head = other.tokens.first

  if tail.ends_with_slash?
    if head.starts_with_slash?
      return self.class.new( remove_double_slash(self.tokens, other.tokens).join )
    end
  elsif !head.starts_with_slash?
    return self.class.new( (self.tokens + ['/'] + other.tokens).join)
  end
  return self.class.new( (self.tokens + other.tokens).join )
end

# File lib/uri_template.rb, line 323
def pattern
  @pattern ||= tokens.map(&:to_s).join
end

# File lib/uri_template.rb, line 447
def relative?
  !absolute?
end

# File lib/uri_template.rb, line 316
def scheme?
  return scheme_and_host[0]
end

# File lib/uri_template.rb, line 281
def static_characters
  @static_characters ||= tokens.select(&:literal?).map{|t| t.string.size }.inject(0,:+)
end

# File lib/uri_template.rb, line 257
def tokens
  raise "Please implement #tokens on #{self.class.inspect}."
end

# File lib/uri_template.rb, line 249
def type
  raise "Please implement #type on #{self.class.inspect}."
end

# File lib/uri_template.rb, line 267
def variables
  @variables ||= tokens.map(&:variables).flatten.uniq.freeze
end

# File lib/uri_template.rb, line 229
def normalize_variables( variables )
  raise ArgumentError, "Expected something that responds to :map, but got: #{variables.inspect}" unless variables.respond_to? :map
  if variables.kind_of?(Array)
    return Hash[self.variables.zip(variables)]
  else
    # Stringify variables
    arg = variables.map{ |k, v| [k.to_s, v] }
    if arg.any?{|elem| !elem.kind_of?(Array) }
      raise ArgumentError, "Expected the output of variables.map to return an array of arrays but got #{arg.inspect}"
    end
    return Hash[arg]
  end
end

# File lib/uri_template.rb, line 399
def remove_double_slash( first_tokens, second_tokens )
  if first_tokens.last.literal?
    return first_tokens[0..-2] + [ first_tokens.last.to_s[0..-2] ] + second_tokens
  elsif second_tokens.first.literal?
    return first_tokens + [ second_tokens.first.to_s[1..-1] ] + second_tokens[1..-1]
  else
    raise ArgumentError, "Cannot remove double slashes from #{first_tokens.inspect} and #{second_tokens.inspect}."
  end
end

# File lib/uri_template.rb, line 412
def scheme_and_host
  return @scheme_and_host if @scheme_and_host
  read_chars = ""
  @scheme_and_host = [false,false]
  tokens.each do |token|
    if token.expression?
      read_chars << "x"
      if token.scheme?
        read_chars << ':'
      end
      if token.host?
        read_chars << '//'
      end
      read_chars << "x"
    elsif token.literal?
      read_chars << token.string
    end
    if read_chars =~ SCHEME_REGEX
      @scheme_and_host = [true, true]
      break
    elsif read_chars =~ HOST_REGEX
      @scheme_and_host[1] = true
      break
    elsif read_chars =~ /(^|[^:\/])\/(?!\/)/
      break
    end
  end
  return @scheme_and_host
end