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

class
	P2P_RESOLVER_RESPONSE

inherit
	P2P_XML_CACHE
		redefine
			document,
			validate
		end

create
	make,
	make_from_element,
	parse_from_string,
	make_from_query

feature {NONE} -- Initialization

	make (a_response_peer_id: like response_peer_id; a_handler_name: like handler_name; a_query_id: like query_id; a_response: like response) is
			-- Create new resolver query message
		require
			Peer_id_valid: a_response_peer_id /= Void and a_response_peer_id.is_valid
			Handler_name_valid: a_handler_name /= Void
			Query_id_valid: a_query_id >= 0
			Response_valid: a_response /= Void
		do
			initialize
			set_response_peer_id (a_response_peer_id)
			set_handler_name (a_handler_name)
			set_query_id (a_query_id)
			set_response (a_response)
			is_valid := True
		ensure
			Peer_id_set: response_peer_id = a_response_peer_id
			Handler_name_set: handler_name.is_equal (a_handler_name)
			Query_id_set: query_id = a_query_id
			Response_set: response = a_response
		end

	make_from_query (a_query: P2P_RESOLVER_QUERY; a_response_peer_id: like response_peer_id; a_response: like response) is
			-- Create new response to given `a_query'
		require
			Query_valid: a_query /= Void and a_query.is_valid
			Peer_id_valid: a_response_peer_id /= Void and a_response_peer_id.is_valid
			Response_valid: a_response /= Void
		do
			make (a_response_peer_id, a_query.handler_name, a_query.query_id, a_response)
		ensure
			Peer_id_set: response_peer_id = a_response_peer_id
			Handler_name_set: handler_name.is_equal (a_query.handler_name)
			Query_id_set: query_id = a_query.query_id
			Response_set: response = a_response
		end

feature -- Access

	handler_name: STRING
	response_peer_id: P2P_PEER_ID
	query_id: INTEGER
	response: STRING

	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_response_peer_id.is_equal (an_element_name) then
				Result := does_element_match (response_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_response.is_equal (an_element_name) then
				Result := does_element_match (response, 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_response_peer_id (an_id: like response_peer_id) is
			-- Set source peer id
		require
			Peer_id_valid: an_id /= Void and an_id.is_valid
		do
			response_peer_id := an_id
			renew_document
		ensure
			Peer_id_set: response_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_response (a_response: like response) is
			-- Set query
		require
			Response_valid: a_response /= Void
		do
			response := a_response
			renew_document
		ensure
			Response_set: response.is_equal (a_response)
		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 ResPeerID
				Result.create_root_child_element (element_response_peer_id, Result.namespace_empty)
				Result.create_content (Result.last_element, response_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 Response
				Result.create_root_child_element (element_response, Result.namespace_empty)
				Result.create_content (Result.last_element, response)
			end
		end

feature {NONE} -- Implementation

	Element_credential: STRING is "Cred"
	Element_response_peer_id: STRING is "ResPeerID"
	Element_handler_name: STRING is "HandlerName"
	Element_query_id: STRING is "QueryID"
	Element_response: STRING is "Response"

	root_element_name: STRING is "ResolverResponse"

	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: STRING
		do
			if element_response_peer_id.is_equal (element.name) then
				create response_peer_id.make_from_urn (element.text)
				if not response_peer_id.is_valid then
					response_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_response.is_equal (element.name) then
				response := trimmed (element.text)
			end
		end

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

end