/*
 * Copyright 2008 Oliver Ruiz Dorantes, oliver.ruiz.dorantes_at_gmail.com
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include <KernelExport.h>
#include <string.h>

#include <NetBufferUtilities.h>
#include <net_protocol.h>

#include <bluetooth/HCI/btHCI_acl.h>
#include <bluetooth/HCI/btHCI_transport.h>
#include <bluetooth/HCI/btHCI_event.h>
#include <bluetooth/bdaddrUtils.h>

#include <btDebug.h>
#include <btCoreData.h>
#include <btModules.h>
#include <l2cap.h>

#include "acl.h"

extern struct bluetooth_core_data_module_info* btCoreData;

struct net_protocol_module_info* L2cap = NULL;

extern void RegisterConnection(hci_id hid, uint16 handle);
extern void unRegisterConnection(hci_id hid, uint16 handle);

status_t PostToUpper(HciConnection* conn, net_buffer* buf);

status_t
AclAssembly(net_buffer* nbuf, hci_id hid)
{
	status_t	error = B_OK;

	// Check ACL data packet. Driver should ensure report complete ACL packets
	if (nbuf->size < sizeof(struct hci_acl_header)) {
		ERROR("%s: Invalid ACL data packet, small length=%" B_PRIu32 "\n",
			__func__, nbuf->size);
		gBufferModule->free(nbuf);
		return (EMSGSIZE);
	}

	// Strip ACL data packet header
	NetBufferHeaderReader<struct hci_acl_header> aclHeader(nbuf);
	status_t status = aclHeader.Status();
	if (status < B_OK) {
		gBufferModule->free(nbuf);
		return ENOBUFS;
	}

	// Get ACL connection handle, PB flag and payload length
	aclHeader->handle = B_LENDIAN_TO_HOST_INT16(aclHeader->handle);

	uint16 con_handle = get_acl_handle(aclHeader->handle);
	uint16 pb = get_acl_pb_flag(aclHeader->handle);
	uint16 length = B_LENDIAN_TO_HOST_INT16(aclHeader->alen);

	aclHeader.Remove();

	TRACE("%s: ACL data packet, handle=%#x, PB=%#x, length=%d\n", __func__,
		con_handle, pb, length);

	// a) Ensure there is HCI connection
	// b) Get connection descriptor
	// c) veryfy the status of the connection

	HciConnection* conn = btCoreData->ConnectionByHandle(con_handle, hid);
	if (conn == NULL) {
		ERROR("%s: expected handle=%#x does not exist!\n", __func__,
			con_handle);
		conn = btCoreData->AddConnection(con_handle, BT_ACL, BDADDR_NULL, hid);
	}

	// Verify connection state
	if (conn->status!= HCI_CONN_OPEN) {
		ERROR("%s: unexpected ACL data packet. Connection not open\n",
			__func__);
		gBufferModule->free(nbuf);
		return EHOSTDOWN;
	}


	// Process packet
	if (pb == HCI_ACL_PACKET_START) {
		if (conn->currentRxPacket != NULL) {
			TRACE("%s: Dropping incomplete L2CAP packet, got %" B_PRIu32
				" want %d \n", __func__, conn->currentRxPacket->size, length );
			gBufferModule->free(conn->currentRxPacket);
			conn->currentRxPacket = NULL;
			conn->currentRxExpectedLength = 0;
		}

		// Get L2CAP header, ACL header was dimissed
		if (nbuf->size < sizeof(l2cap_basic_header)) {
			TRACE("%s: Invalid L2CAP start fragment, small, length=%" B_PRIu32
				"\n", __func__, nbuf->size);
			gBufferModule->free(nbuf);
			return (EMSGSIZE);
		}

		NetBufferHeaderReader<l2cap_basic_header> l2capHeader(nbuf);
		if (l2capHeader.Status() != B_OK) {
			gBufferModule->free(nbuf);
			return ENOBUFS;
		}

		TRACE("%s: New L2CAP, handle=%#x length=%d\n", __func__, con_handle,
			le16toh(l2capHeader->length));

		// Start new L2CAP packet
		conn->currentRxPacket = nbuf;
		conn->currentRxExpectedLength = B_LENDIAN_TO_HOST_INT16(l2capHeader->length)
			+ sizeof(l2cap_basic_header);
	} else if (pb == HCI_ACL_PACKET_FRAGMENT) {
		if (conn->currentRxPacket == NULL) {
			gBufferModule->free(nbuf);
			return (EINVAL);
		}

		// Add fragment to the L2CAP packet
		gBufferModule->merge(conn->currentRxPacket, nbuf, true);
	} else {
		ERROR("%s: invalid ACL data packet. Invalid PB flag=%#x\n", __func__,
			pb);
		gBufferModule->free(nbuf);
		return (EINVAL);
	}

	// substract the length of content of the ACL packet
	conn->currentRxExpectedLength -= length;

	if (conn->currentRxExpectedLength < 0) {
		TRACE("%s: Mismatch. Got %" B_PRIu32 ", expected %" B_PRIuSIZE "\n",
			__func__, conn->currentRxPacket->size,
			conn->currentRxExpectedLength);

		gBufferModule->free(conn->currentRxPacket);
		conn->currentRxPacket = NULL;
		conn->currentRxExpectedLength = 0;

	} else if (conn->currentRxExpectedLength == 0) {
		// OK, we have got complete L2CAP packet, so process it
		TRACE("%s: L2cap packet ready %" B_PRIu32 " bytes\n", __func__,
			conn->currentRxPacket->size);

		memcpy(conn->currentRxPacket->source, &conn->address_dest, sizeof(sockaddr_storage));
		conn->currentRxPacket->interface_address = &conn->interface_address;

		error = PostToUpper(conn, conn->currentRxPacket);
		// clean
		conn->currentRxPacket = NULL;
		conn->currentRxExpectedLength = 0;
	} else {
		TRACE("%s: Expected %ld current adds %d\n", __func__,
			conn->currentRxExpectedLength, length);
	}

	return error;
}


status_t
PostToUpper(HciConnection* conn, net_buffer* buf)
{
	if (L2cap == NULL)

	if (get_module(NET_BLUETOOTH_L2CAP_NAME, (module_info**)&L2cap) != B_OK) {
		ERROR("%s: cannot get module \"%s\"\n", __func__,
			NET_BLUETOOTH_L2CAP_NAME);
		return B_ERROR;
	} // TODO: someone put it

	return L2cap->receive_data(buf);
}