indexing
	description: "Represents a resolver query message"
	license: "MIT license (see ../../license.txt)"
	author: "Beat Strasser <beat@stradax.net>"
	date: "$Date$"
	revision: "$Revision$"

class
	P2P_RESOLVER_QUERY

inherit
	P2P_XML_CACHE
		redefine
			document,
			validate
		end

create
	make,
	make_from_element,
	parse_from_string

feature {NONE} -- Initialization

	make (a_source_peer_id: like source_peer_id; a_handler_name: like handler_name; a_query_id: like query_id; a_query: like query) is
			-- Create new resolver query message
		require
			Peer_id_valid: a_source_peer_id /= Void and a_source_peer_id.is_valid
			Handler_name_valid: a_handler_name /= Void
			Query_id_valid: a_query_id > 0
			Query_valid: a_query /= Void
		do
			initialize
			set_source_peer_id (a_source_peer_id)
			set_handler_name (a_handler_name)
			set_query_id (a_query_id)
			set_query (a_query)
			is_valid := True
		ensure
			Peer_id_set: source_peer_id = a_source_peer_id
			Handler_name_set: handler_name.is_equal (a_handler_name)
			Query_id_set: query_id = a_query_id
			Query_set: query = a_query
		end

feature -- Access

	handler_name: STRING
	source_peer_id: P2P_PEER_ID
	query_id: INTEGER
	hop_count: INTEGER
	query: STRING
	source_peer_route: P2P_ROUTE_ADVERTISEMENT

	repropagate: BOOLEAN
			-- Should query be repropagated? Not included in the document.

	match (an_element_name, an_element_value: STRING): BOOLEAN is
			-- Is given element's value equal with `an_element_value'?
		do
			if element_handler_name.is_equal (an_element_name) then
				Result := does_element_match (handler_name, an_element_value)
			elseif element_source_peer_id.is_equal (an_element_name) then
				Result := does_element_match (source_peer_id, an_element_value)
			elseif element_query_id.is_equal (an_element_name) then
				Result := does_element_match (query_id, an_element_value)
			elseif element_hop_count.is_equal (an_element_name) then
				Result := does_element_match (hop_count, an_element_value)
			elseif element_query.is_equal (an_element_name) then
				Result := does_element_match (query, an_element_value)
			end
		end

feature -- Element change

	set_handler_name (a_name: like handler_name) is
			-- Set handler name
		require
			Handler_name_valid: a_name /= Void
		do
			handler_name := a_name
			renew_document
		ensure
			Handler_name_set: handler_name.is_equal (a_name)
		end

	set_source_peer_id (an_id: like source_peer_id) is
			-- Set source peer id
		require
			Peer_id_valid: an_id /= Void and an_id.is_valid
		do
			source_peer_id := an_id
			renew_document
		ensure
			Peer_id_set: source_peer_id = an_id
		end

	set_query_id (an_id: like query_id) is
			-- Set query id
		require
			Query_id_valid: an_id > 0
		do
			query_id := an_id
			renew_document
		ensure
			Query_id_set: query_id = an_id
		end

	set_hop_count (a_count: like hop_count) is
			-- Set hop count
		require
			Count_valid: a_count >= 0
		do
			hop_count := a_count
			renew_document
		ensure
			Hop_count_set: hop_count = a_count
		end

	set_query (a_query: like query) is
			-- Set query
		require
			Query_valid: a_query /= Void
		do
			query := a_query
			renew_document
		ensure
			Query_set: query.is_equal (a_query)
		end

	increment_hop_count is
			-- Increment hop count
		do
			hop_count := hop_count + 1
			renew_document
		end

	set_source_peer_route (a_route: like source_peer_route) is
			-- Set source peer route
		require
			Route_valid: a_route /= Void and a_route.is_valid
		do
			source_peer_route := a_route
			renew_document
		ensure
			Route_set: source_peer_route.is_equal (a_route)
		end

	set_repropagate (should_repropagate: like repropagate) is
			-- Should query be repropagated? Not included in the document.
		do
			repropagate := should_repropagate
		ensure
			Value_set: repropagate = should_repropagate
		end

feature -- Output

	document: P2P_XML_DOCUMENT is
			-- Create XML document
		local
			cached: BOOLEAN
		do
			cached := cached_document /= Void
			-- create document
			Result := Precursor

			if not cached then
				-- Element SrcPeerID
				Result.create_root_child_element (element_source_peer_id, Result.namespace_empty)
				Result.create_content (Result.last_element, source_peer_id.out)
				-- Element HandlerName
				Result.create_root_child_element (element_handler_name, Result.namespace_empty)
				Result.create_content (Result.last_element, handler_name)
				-- Element QueryID
				Result.create_root_child_element (element_query_id, Result.namespace_empty)
				Result.create_content (Result.last_element, query_id.out)
				-- Element HC
				Result.create_root_child_element (element_hop_count, Result.namespace_empty)
				Result.create_content (Result.last_element, hop_count.out)
				-- Element Query
				Result.create_root_child_element (element_query, Result.namespace_empty)
				Result.create_content (Result.last_element, query)
				-- Element SrcPeerRoute
				if source_peer_route /= Void then
					Result.create_root_child_element (element_source_peer_route, Result.namespace_empty)
					Result.add_child_element (Result.last_element, source_peer_route.document.document.root_element.deep_twin)
				end
			end
		end

feature {NONE} -- Implementation

	Element_credential: STRING is "Cred"
	Element_source_peer_id: STRING is "SrcPeerID"
	Element_handler_name: STRING is "HandlerName"
	Element_query_id: STRING is "QueryID"
	Element_hop_count: STRING is "HC"
	Element_query: STRING is "Query"
	Element_source_peer_route: STRING is "SrcPeerRoute"

	root_element_name: STRING is "ResolverQuery"

	attribute_handler (root_attribute: XM_ATTRIBUTE) is
			-- No attributes
		do
		end

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed advertisement
		local
			qid, hc: STRING
			route_elements: DS_LIST [XM_ELEMENT]
		do
			if element_source_peer_id.is_equal (element.name) then
				create source_peer_id.make_from_urn (element.text)
				if not source_peer_id.is_valid then
					source_peer_id := Void
				end
			elseif element_handler_name.is_equal (element.name) then
				handler_name := trimmed (element.text)
			elseif element_query_id.is_equal (element.name) then
				qid := trimmed (element.text)
				if qid /= Void and qid.is_integer then
					query_id := qid.to_integer
				end
			elseif element_hop_count.is_equal (element.name) then
				hc := trimmed (element.text)
				if hc /= Void and hc.is_integer then
					hop_count := hc.to_integer
				end
			elseif element_query.is_equal (element.name) then
				query := trimmed (element.text)
			elseif element_source_peer_route.is_equal (element.name) then
				route_elements := element.elements
				if route_elements.count = 1 then
					create source_peer_route.make_from_element (route_elements.first.deep_twin)
					if not source_peer_route.is_valid then
						source_peer_route := Void
					end
				end
			end
		end

	validate is
			-- Validate message and set `is_valid'
		do
			is_valid := is_valid and handler_name /= Void and source_peer_id /= Void and query_id /= 0 and hop_count >= 0 and query /= Void
		end

end