indexing
	description: "ID in UUID format"
	license: "MIT license (see ../license.txt)"
	author: "Beat Strasser <beat@stradax.net>"
	date: "$Date$"
	revision: "$Revision$"

deferred class
	P2P_ID_UUID

inherit
	P2P_UUID_TOOLS
		undefine
			out,
			is_equal
		end
	P2P_ID
		redefine
			parse_unique_id,
			is_unique_id_valid
		end

feature -- Access

	format: STRING is "uuid"
	bytes: ARRAY [NATURAL_8]
	flag_id_type: NATURAL_8 is
			-- Current flag id type
		deferred
		end

	uuid: ARRAY [NATURAL_8] is
			-- Characteristic UUID (ID part)
		do
			Result := subbytes (characteristic_uuid_msb, characteristic_uuid_lsb)
		ensure
			Result_set: Result /= Void and Result.lower = 0 and Result.count = uuid_bytes_count
		end

	Minimal_bytes_count: INTEGER is 1
	Maximal_bytes_count: INTEGER is 64
	Flags_bytes_count: INTEGER is 1

feature -- Status report

	is_unique_id_valid (an_id: STRING): BOOLEAN is
			-- Is `an_id' a valid unique id?
		do
			Result := Precursor (an_id) and an_id.count \\ 2 = 0 and an_id.count > minimal_bytes_count * 2
				and an_id.count <= maximal_bytes_count * 2
		end

feature {NONE} -- Implementation

	Characteristic_uuid_msb: INTEGER is
			-- Characteristic UUID MSB
		deferred
		end

	Characteristic_uuid_lsb: INTEGER is
			-- Characteristic UUID LSB
		deferred
		end

	parse_unique_id is
			-- Parse `unique_id'.
		local
			source_pos: INTEGER
		do
			-- make sure, id is in uppercase form
			unique_id.to_upper
			-- parse id to array
			from
				source_pos := 1
				initialize_bytes
			until
				source_pos > unique_id.count - flags_bytes_count * 2
			loop
				bytes[source_pos // 2] := hex_to_natural_8 (unique_id.item (source_pos), unique_id.item (source_pos + 1))
				source_pos := source_pos + 2
			end
			-- parse flags
			bytes[maximal_bytes_count - 1] := hex_to_natural_8 (unique_id.item (unique_id.count - 1), unique_id.item (unique_id.count))
			-- parse bytes
			parse_bytes
		end

	parse_bytes is
			-- Parse `bytes'. Check if characteristic bytes are non-zero (valid).
		local
			i: INTEGER
		do
			from
				i := characteristic_uuid_msb
			until
				bytes[i] /= 0 or i > characteristic_uuid_lsb
			loop
				i := i + 1
			end
			is_valid := (i <= characteristic_uuid_lsb)
		end

	initialize_bytes is
			-- Initialize bytes array
		do
			create bytes.make (minimal_bytes_count - 1, maximal_bytes_count - 1)
		end

	build_uuidformat is
			-- Build uuid format
		local
			id: STRING
			last, pos: INTEGER
		do
			-- look for last used byte (except the flag)
			from
				last := maximal_bytes_count - 2
			until
				last < 0 or bytes[last] /= 0
			loop
				last := last - 1
			end
			-- build hex string
			create id.make (maximal_bytes_count + 1)
			from
				pos := 0
			until
				pos > last
			loop
				id.append (bytes[pos].to_hex_string)
				pos := pos + 1
			end
			bytes[maximal_bytes_count - 1] := flag_id_type
			id.append (flag_id_type.to_hex_string)
			id.to_upper
			-- P2P_ID initialization
			make_with_id (id)
		end

	subbytes (start_pos, end_pos: INTEGER): like bytes is
			-- Sub array of `bytes', from `start_pos' to `end_pos'
		do
			create Result.make (0, end_pos - start_pos)
			Result.subcopy (bytes, start_pos, end_pos, 0)
		ensure
			Result_set: Result /= Void and Result.lower = 0 and Result.upper = end_pos - start_pos
		end

end