indexing
	description: "Represents a peer advertisement document"
	author: "Beat Strasser <beat@stradax.net>"
	date: "$Date$"
	revision: "$Revision$"

class
	P2P_PEER_ADVERTISEMENT

inherit
	P2P_ADVERTISEMENT
		redefine
			initialize,
			document,
			validate
		end
	P2P_XML_DOCUMENT_CREATOR
		undefine
			out
		end

create
	make,
	make_from_element,
	parse_from_string,
	copy

feature {NONE} -- Initialization

	make (a_peer_id: like peer_id; a_group_id: like group_id) is
			-- Create new peer advertisement
		require
			Pid_valid: a_peer_id /= Void
			Gid_valid: a_group_id /= Void
		do
			initialize
			set_peer_id (a_peer_id)
			set_group_id (a_group_id)

			is_valid := True
		ensure
			Pid_set: peer_id.is_equal (a_peer_id)
			Gid_set: group_id.is_equal (a_group_id)
		end

feature -- Access

	peer_id: P2P_PEER_ID
	group_id: P2P_PEERGROUP_ID
	name: STRING
	description: STRING
	service_parameters: LINKED_LIST [TUPLE [P2P_MODULE_CLASS_ID, P2P_ADVERTISEMENT]]

	service_parameter (a_module_class_id: P2P_MODULE_CLASS_ID): P2P_ADVERTISEMENT is
			-- First Parameter advertisement for service with given class id
		require
			Id_existent: a_module_class_id /= Void
		do
			goto_service_parameter (a_module_class_id)
			if not service_parameters.after then
				Result ?= service_parameters.item @ 2
			end
		end

	match (an_element_name, an_element_value: STRING): BOOLEAN is
			-- Is given element's value equal with `an_element_value'?
		do
			if element_peer_id.is_equal (an_element_name) then
				Result := does_element_match (peer_id, an_element_value)
			elseif element_group_id.is_equal (an_element_name) then
				Result := does_element_match (group_id, an_element_value)
			elseif element_name.is_equal (an_element_name) then
				Result := does_element_match (name, an_element_value)
			elseif element_description.is_equal (an_element_name) then
				Result := does_element_match (description, an_element_value)
			end
		end

feature -- Element change

	set_peer_id (a_peer_id: like peer_id) is
			-- Set new peer id
		require
			Pid_valid: a_peer_id /= Void
		do
			peer_id := a_peer_id
			renew_document
		ensure
			Pid_set: peer_id.is_equal (a_peer_id)
		end

	set_group_id (a_group_id: like group_id) is
			-- Set new group id
		require
			Gid_valid: a_group_id /= Void
		do
			group_id := a_group_id
			renew_document
		ensure
			Gid_set: group_id.is_equal (a_group_id)
		end

	set_name (a_name: like name) is
			-- Set new name
		require
			Name_valid: a_name /= Void
		do
			name := a_name
			renew_document
		ensure
			Name_set: name.is_equal (a_name)
		end

	set_description (a_description: like description) is
			-- Set new description
		require
			Description_valid: a_description /= Void
		do
			description := a_description
			renew_document
		ensure
			Description_set: description.is_equal (a_description)
		end

	replace_service_parameter (a_module_class_id: P2P_MODULE_CLASS_ID; a_parameter: P2P_ADVERTISEMENT) is
			-- Replace service parameter for given module class
		require
			Mcid_valid: a_module_class_id /= Void
			Parameter_valid: a_parameter /= Void
		do
			goto_service_parameter (a_module_class_id)
			if service_parameters.after then
				service_parameters.extend ([a_module_class_id, a_parameter])
			else
				service_parameters.replace ([a_module_class_id, a_parameter])
			end
			renew_document
		ensure
			Parameter_set: service_parameters.has ([a_module_class_id, a_parameter])
		end

feature -- Removal

	remove_service_parameter (a_module_class_id: P2P_MODULE_CLASS_ID) is
			-- Remove first found service parameter of given module class
		do
			goto_service_parameter (a_module_class_id)
			if not service_parameters.after then
				service_parameters.remove
				renew_document
			end
		end

feature -- Output

	document: P2P_XML_DOCUMENT is
			-- Create XML document
		local
			el_svc, el_parm: XM_ELEMENT
			mcid: P2P_MODULE_CLASS_ID
			parm: P2P_ADVERTISEMENT
			cached: BOOLEAN
		do
			cached := cached_document /= Void
			-- create document
			Result := Precursor

			if not cached then
				-- element PID
				Result.create_root_child_element (element_peer_id, Result.namespace_empty)
				Result.create_content (Result.last_element, peer_id.out)
				-- element GID
				Result.create_root_child_element (element_group_id, Result.namespace_empty)
				Result.create_content (Result.last_element, group_id.out)
				-- element Name
				if name /= Void then
					Result.create_root_child_element (element_name, Result.namespace_empty)
					Result.create_content (Result.last_element, name)
				end
				-- element Desc
				if description /= Void then
					Result.create_root_child_element (element_description, Result.namespace_empty)
					Result.create_content (Result.last_element, description)
				end
				-- elements Svc
				from
					service_parameters.start
				until
					service_parameters.after
				loop
					mcid ?= service_parameters.item @ 1
					parm ?= service_parameters.item @ 2
					if mcid /= Void and parm /= Void then
						Result.create_root_child_element (element_service_parameters, Result.namespace_empty)
						el_svc := Result.last_element
						Result.create_child_element (el_svc, element_service_parameter_mcid, Result.namespace_empty)
						Result.create_content (Result.last_element, mcid.out)
						Result.create_child_element (el_svc, element_service_parameter_parm, Result.namespace_empty)
						el_parm := parm.document.document.root_element.deep_twin -- use a copy, because the elements are double linked
						Result.add_child_element (Result.last_element, el_parm)
					end
					service_parameters.forth
				end
			end
		end

feature {NONE} -- Implementation

	Element_peer_id: STRING is "PID"
	Element_group_id: STRING is "GID"
	Element_name: STRING is "Name"
	Element_description: STRING is "Desc"
	Element_service_parameters: STRING is "Svc"
	Element_service_parameter_mcid: STRING is "MCID"
	Element_service_parameter_parm: STRING is "Parm"
	Type_peer_id: STRING is "jxta:JXTAID"
	Type_group_id: STRING is "jxta:JXTAID"
	Type_name: STRING is "xs:string"
	Type_description: STRING is "xs:anyType"
	Type_service_parameters: STRING is "jxta:serviceParams"
	Type_service_parameter_mcid: STRING is "jxta:JXTAID"
	Type_service_parameter_parm: STRING is "xs:anyType"

	root_element_name: STRING is "PA"

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed advertisement
		local
			el_mcid, el_parm: XM_ELEMENT
			parm: P2P_ADVERTISEMENT
			mcid: P2P_MODULE_CLASS_ID
		do
			if element_peer_id.is_equal (element.name) then
				create peer_id.make_from_urn (element_text (element))
				if not peer_id.is_valid then
					peer_id := Void
				end
			elseif element_group_id.is_equal (element.name) then
				group_id := create_peergroup_id (element_text (element))
			elseif element_name.is_equal (element.name) then
				name := trimmed (element.text)
			elseif element_description.is_equal (element.name) then
				description := trimmed (element.text)
			elseif element_service_parameters.is_equal (element.name) then
				el_mcid := element.element_by_name (element_service_parameter_mcid)
				el_parm := element.element_by_name (element_service_parameter_parm)
				if el_mcid /= Void and el_parm /= Void then
					create mcid.make_from_urn (element_text (el_mcid))
					parm := advertisement_from_element (el_parm.deep_twin) -- use copy, because elements are double linked
					if mcid.is_valid and parm /= Void then
						service_parameters.extend ([mcid, parm])
					end
				end
			end
		end

	validate is
			-- Validate advertisement and set `is_valid'
		do
			is_valid := is_valid and peer_id /= Void and group_id /= Void
		end

	goto_service_parameter (mcid: P2P_MODULE_CLASS_ID) is
			-- Goto service parameter with given module class id
		require
			Id_valid: mcid /= Void
		local
			current_id: P2P_MODULE_CLASS_ID
			found: BOOLEAN
		do
			from
				service_parameters.start
			until
				found or service_parameters.after
			loop
				current_id ?= service_parameters.item @ 1
				if current_id /= Void and mcid.is_equal (current_id) then
					found := True
				else
					service_parameters.forth
				end
			end
		end

	initialize is
			-- Initialize object's data structure
		do
			Precursor
			create service_parameters.make
			service_parameters.compare_objects
		end

invariant
	Parameters_existent: service_parameters /= Void

end