class Protocol::HTTP::Reference

def self.[] reference
	if reference.is_a? self
		return reference
	else
		return self.parse(reference)
	end
end

def self.parse(path = "/", parameters = nil)
	base, fragment = path.split("#", 2)
	path, query = base.split("?", 2)
	
	self.new(path, query, fragment, parameters)
end

def + other
	other = self.class[other]
	
	self.class.new(
		expand_path(self.path, other.path, true),
		other.query,
		other.fragment,
		other.parameters,
	)
end

def <=> other
	to_ary <=> other.to_ary
end

def append(buffer = String.new)
	if query?
		buffer << URL.escape_path(@path) << "?" << @query
		buffer << "&" << URL.encode(@parameters) if parameters?
	else
		buffer << URL.escape_path(@path)
		buffer << "?" << URL.encode(@parameters) if parameters?
	end
	
	if fragment?
		buffer << "#" << URL.escape(@fragment)
	end
	
	return buffer
end

def base
	self.class.new(@path, nil, nil, nil)
end

def expand_absolute_path(path, parts)
	parts.each do |part|
		if part == ".."
			path.pop
		elsif part == "."
			# Do nothing.
		else
			path << part
		end
	end
	
	if path.first != ""
		path.unshift("")
	end
end

def expand_path(base, relative, pop = true)
	if relative.start_with? "/"
		return relative
	end
	
	path = split(base)
	
	# RFC2396 Section 5.2:
	# 6) a) All but the last segment of the base URI's path component is
	# copied to the buffer.  In other words, any characters after the
	# last (right-most) slash character, if any, are excluded.
	path.pop if pop or path.last == ""
	
	parts = split(relative)
	
	# Absolute path:
	if path.first == ""
		expand_absolute_path(path, parts)
	else
		expand_relative_path(path, parts)
	end	
	
	return path.join("/")
end

def expand_relative_path(path, parts)
	parts.each do |part|
		if part == ".." and path.any?
			path.pop
		elsif part == "."
			# Do nothing.
		else
			path << part
		end
	end
end

def fragment?
	@fragment and !@fragment.empty?
end

def freeze
	return self if frozen?
	
	@path.freeze
	@query.freeze
	@fragment.freeze
	@parameters.freeze
	
	super
end

def initialize(path = "/", query = nil, fragment = nil, parameters = nil)
	@path = path
	@query = query
	@fragment = fragment
	@parameters = parameters
end

def parameters?
	@parameters and !@parameters.empty?
end

def query?
	@query and !@query.empty?
end

def split(path)
	if path.empty?
		[path]
	else
		path.split("/", -1)
	end
end

def to_ary
	[@path, @query, @fragment, @parameters]
end

def to_s
	append
end

def with(path: nil, parameters: nil, fragment: @fragment, pop: false, merge: true)
	if @parameters
		if parameters and merge
			parameters = @parameters.merge(parameters)
		else
			parameters = @parameters
		end
	end
	
	if @query and !merge
		query = nil
	else
		query = @query
	end
	
	if path
		path = expand_path(@path, path, pop)
	else
		path = @path
	end
	
	self.class.new(path, query, fragment, parameters)
end