local form_field = require 'form_field'

--

local F = { }

local M = { }

M.__index = M

-- form.new       -- new form

-- form.parse     -- parse existing form -- according to form type!

-- form:type      -- get type

-- form:desc      -- get title, instructions

-- form:format    -- format form -- according to form type!

-- form:fields    -- iterator, returns field objects

-- form:add       -- create field

-- form:field     -- get field

-- ?? form:del    -- delete field

-- field.new      -- create field

-- field:index    -- get index

-- field:type     -- get type

-- field:name     -- get var

-- field:desc     -- get label, desc

-- field:value    -- get/set value

-- field:values   -- get values

-- field:clear    -- clear value

-- field:options  -- get options

-- field:required -- get required

-- form    may have 'fixed' fields and should be ordered

-- submit  must not have 'fixed' fields and may be not ordered

-- cancel  must not have anything

-- result  should not have 'fixed', may be not ordered and can contain reported/item... multiple instances.

function F.new ( args )

	local form  = {

		xmlns        = 'jabber:x:data',

		ftype        = args.type or 'form',

		title        = args.title,

		instructions = args.instructions,

		f            = { },

	}

	setmetatable ( form, M )

	return form

function F.parse ( x )

		title = title:value ()

		instructions = instructions:value ()

	local f = F.new { type = x:attribute ( 'type' ), title = title, instructions = instructions }

		local name = field:name ()

		if name == 'field' then

			local var   = field:attribute ( 'var' )

				r.desc = desc:value ()

						options[item:child( 'value' ):value ()] = item:attribute ( 'label' ) or ''

			f:add ( var, r )

function M.type ( form )

	return form.ftype

function M.desc ( form )

	return form.title, form.instructions

function M.format ( form, root, format_as )

	local ft = format_as or form:type ()

	root.x = { xmlns = 'jabber:x:data', type = ft }

	if ft == 'cancel' then

		return root

	end

	if ft == 'form' then

		local title, instructions = form:desc ()

		if title then

			root.x.title = { title }

		end

		if instructions then

			root.x.instructions = { instructions }

		end

	end

	local fields = { }

	for i, field in form:fields () do

		local ftype = field:type ()

		local options, label, desc, required

		if ft == 'form' then

			label, desc = field:desc ()

			if desc then

				desc = { desc }

			end

			if field:required () then

				required = { }

			end

			for option, label in field:options () do

				table.insert ( options, { label = label, value = { option } } )

			end

		end

		local value

		if ftype == 'list-multi' or ftype == 'text-multi' or ftype == 'jid-multi' then

			if ft == 'form' then

				for option, label in field:options () do

					table.insert ( options, { label = label, value = { option } } )

			end

			value = { }

			for j, v in ipairs ( field.value ) do

				table.insert ( value, { v } )

			value = { field:value () }

		end

		if ftype ~= 'fixed' or ft == 'form' then

			table.insert ( fields, {

					type   = ftype,

					var    = field:name (),

					label  = label,

					desc   = desc,

					value  = value,

					option = options

				} )

	end

	root.x.field = fields

	return root

end

function M.fields ( form )

	return ipairs ( form.f )

end

function M.add ( form, var, fld )

	fld.var   = var

	fld.index = #form.f + 1 -- XXX

	local obj = form_field.new ( fld )

	table.insert ( form.f, obj )

	form.f[var] = obj

	return obj

end

function M.field ( form, var )

	-- works well on indices

	return form.f[var]

end

return F