/*
 * Copyright 2009-2011, Michael Lotz, mmlr@mlotz.ch.
 * Distributed under the terms of the MIT License.
 */

#ifndef USERLAND_HID
#include "Driver.h"
#else
#include "UserlandHID.h"
#endif

#include "HIDCollection.h"
#include "HIDReport.h"
#include "HIDReportItem.h"

#include <new>
#include <stdlib.h>
#include <string.h>


HIDCollection::HIDCollection(HIDCollection *parent, uint8 type,
	local_item_state &localState)
	:	fParent(parent),
		fType(type),
		fStringID(localState.string_index),
		fPhysicalID(localState.designator_index)
{
	usage_value usageValue;
	if (localState.usage_stack != NULL && localState.usage_stack_used > 0)
		usageValue.u.extended = localState.usage_stack[0].u.extended;
	else if (localState.usage_minimum_set)
		usageValue.u.extended = localState.usage_minimum.u.extended;
	else if (localState.usage_maximum_set)
		usageValue.u.extended = localState.usage_maximum.u.extended;
	else if (type == COLLECTION_LOGICAL) {
		// this is just a logical grouping collection
		usageValue.u.extended = 0;
	} else {
		TRACE_ALWAYS("none of the possible usages for the collection are "
			"set\n");
	}

	fUsage = usageValue.u.extended;
}


HIDCollection::~HIDCollection()
{
	for (int32 i = 0; i < fChildren.Count(); i++)
		delete fChildren[i];
}


uint16
HIDCollection::UsagePage()
{
	usage_value value;
	value.u.extended = fUsage;
	return value.u.s.usage_page;
}


uint16
HIDCollection::UsageID()
{
	usage_value value;
	value.u.extended = fUsage;
	return value.u.s.usage_id;
}


status_t
HIDCollection::AddChild(HIDCollection *child)
{
	if (fChildren.PushBack(child) == B_NO_MEMORY) {
		TRACE_ALWAYS("no memory when trying to resize collection child list\n");
	}

	return B_OK;
}


HIDCollection *
HIDCollection::ChildAt(uint32 index)
{
	int32 count = fChildren.Count();
	if (count < 0 || index >= (uint32)count)
		return NULL;

	return fChildren[index];
}


uint32
HIDCollection::CountChildrenFlat(uint8 type)
{
	uint32 count = 0;
	if (type == COLLECTION_ALL || fType == type)
		count++;

	for (int32 i = 0; i < fChildren.Count(); i++) {
		HIDCollection *child = fChildren[i];
		if (child == NULL)
			continue;

		count += child->CountChildrenFlat(type);
	}

	return count;
}


HIDCollection *
HIDCollection::ChildAtFlat(uint8 type, uint32 index)
{
	return _ChildAtFlat(type, index);
}


void
HIDCollection::AddItem(HIDReportItem *item)
{
	if (fItems.PushBack(item) == B_NO_MEMORY) {
		TRACE_ALWAYS("no memory when trying to resize collection items\n");
	}

}


HIDReportItem *
HIDCollection::ItemAt(uint32 index)
{
	int32 count = fItems.Count();
	if (count < 0 || index >= (uint32)count)
		return NULL;

	return fItems[index];
}


uint32
HIDCollection::CountItemsFlat()
{
	uint32 count = fItems.Count();

	for (int32 i = 0; i < fChildren.Count(); i++) {
		HIDCollection *child = fChildren[i];
		if (child != NULL)
			count += child->CountItemsFlat();
	}

	return count;
}


HIDReportItem *
HIDCollection::ItemAtFlat(uint32 index)
{
	return _ItemAtFlat(index);
}


void
HIDCollection::PrintToStream(uint32 indentLevel)
{
	char indent[indentLevel + 1];
	memset(indent, '\t', indentLevel);
	indent[indentLevel] = 0;

	const char *typeName = "unknown";
	switch (fType) {
		case COLLECTION_PHYSICAL:
			typeName = "physical";
			break;
		case COLLECTION_APPLICATION:
			typeName = "application";
			break;
		case COLLECTION_LOGICAL:
			typeName = "logical";
			break;
		case COLLECTION_REPORT:
			typeName = "report";
			break;
		case COLLECTION_NAMED_ARRAY:
			typeName = "named array";
			break;
		case COLLECTION_USAGE_SWITCH:
			typeName = "usage switch";
			break;
		case COLLECTION_USAGE_MODIFIER:
			typeName = "usage modifier";
			break;
	}

	TRACE_ALWAYS("%sHIDCollection %p\n", indent, this);
	TRACE_ALWAYS("%s\ttype: %u %s\n", indent, fType, typeName);
	TRACE_ALWAYS("%s\tusage: 0x%08" B_PRIx32 "\n", indent, fUsage);
	TRACE_ALWAYS("%s\tstring id: %u\n", indent, fStringID);
	TRACE_ALWAYS("%s\tphysical id: %u\n", indent, fPhysicalID);

	TRACE_ALWAYS("%s\titem count: %" B_PRIu32 "\n", indent, fItems.Count());
	for (int32 i = 0; i < fItems.Count(); i++) {
		HIDReportItem *item = fItems[i];
		if (item != NULL)
			item->PrintToStream(indentLevel + 1);
	}

	TRACE_ALWAYS("%s\tchild count: %" B_PRIu32 "\n", indent, fChildren.Count());
	for (int32 i = 0; i < fChildren.Count(); i++) {
		HIDCollection *child = fChildren[i];
		if (child != NULL)
			child->PrintToStream(indentLevel + 1);
	}
}


HIDCollection *
HIDCollection::_ChildAtFlat(uint8 type, uint32 &index)
{
	if (type == COLLECTION_ALL || fType == type) {
		if (index == 0)
			return this;

		index--;
	}

	for (int32 i = 0; i < fChildren.Count(); i++) {
		HIDCollection *child = fChildren[i];
		if (child == NULL)
			continue;

		HIDCollection *result = child->_ChildAtFlat(type, index);
		if (result != NULL)
			return result;
	}

	return NULL;
}


HIDReportItem *
HIDCollection::_ItemAtFlat(uint32 &index)
{
	int32 count = fItems.Count();
	if (count > 0 && index < (uint32)count)
		return fItems[index];

	index -= fItems.Count();

	for (int32 i = 0; i < fChildren.Count(); i++) {
		HIDCollection *child = fChildren[i];
		if (child == NULL)
			continue;

		HIDReportItem *result = child->_ItemAtFlat(index);
		if (result != NULL)
			return result;
	}

	return NULL;
}


void
HIDCollection::BuildReportList(uint8 reportType,
	HIDReport **reportList, uint32 &reportCount)
{

	for (int32 i = 0; i < fItems.Count(); i++) {
		HIDReportItem *item = fItems[i];
		if (item == NULL)
			continue;

		HIDReport *report = item->Report();
		if (reportType != HID_REPORT_TYPE_ANY && report->Type() != reportType)
			continue;

		bool found = false;
		for (uint32 j = 0; j < reportCount; j++) {
			if (reportList[j] == report) {
				found = true;
				break;
			}
		}

		if (found)
			continue;

		reportList[reportCount++] = report;
	}

	for (int32 i = 0; i < fChildren.Count(); i++) {
		HIDCollection *child = fChildren[i];
		if (child == NULL)
			continue;

		child->BuildReportList(reportType, reportList, reportCount);
	}
}