/*
 * Copyright 2008, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Oliver Ruiz Dorantes, oliver.ruiz.dorantes_at_gmail.com
 */

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

#include <KernelExport.h>
#include <lock.h>
#include <SupportDefs.h>
#include <util/AutoLock.h>
#include <util/DoublyLinkedList.h>

#include <net_buffer.h>
#include <net_device.h>
#include <net_stack.h>
#include <NetBufferUtilities.h>

#include <btDebug.h>
#include <btCoreData.h>
#include <btModules.h>
#include <CodeHandler.h>
#define KERNEL_LAND
#include <PortListener.h>
#undef KERNEL_LAND

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

#include "acl.h"


int32 api_version = B_CUR_DRIVER_API_VERSION;


typedef PortListener<void,
        HCI_MAX_FRAME_SIZE, // Event Body can hold max 255 + 2 header
        24                                      // Some devices have sent chunks of 24 events(inquiry result)
        > BluetoothRawDataPort;


// Modules references
net_buffer_module_info* gBufferModule = NULL;
struct bluetooth_core_data_module_info* btCoreData = NULL;

static mutex sListLock;
static sem_id sLinkChangeSemaphore;
static DoublyLinkedList<bluetooth_device> sDeviceList;

BluetoothRawDataPort* BluetoothRXPort;

// forward declarations
status_t HciPacketHandler(void* data, int32 code, size_t size);


bluetooth_device*
FindDeviceByID(hci_id hid)
{
        bluetooth_device* device;

        DoublyLinkedList<bluetooth_device>::Iterator iterator
                = sDeviceList.GetIterator();

        while (iterator.HasNext()) {
                device = iterator.Next();
                if (device->index == hid)
                        return device;
        }

        return NULL;
}


status_t
PostTransportPacket(hci_id hid, bt_packet_t type, void* data, size_t count)
{
        uint32 code = 0;

        Bluetooth::CodeHandler::SetDevice(&code, hid);
        Bluetooth::CodeHandler::SetProtocol(&code, type);

        return BluetoothRXPort->Trigger(code, data, count);
}


status_t
Assemble(bluetooth_device* bluetoothDevice, bt_packet_t type, void* data,
        size_t count)
{
        net_buffer* nbuf = bluetoothDevice->fBuffersRx[type];

        size_t currentPacketLen = 0;

        while (count) {

                if (nbuf == NULL) {
                        // new buffer incoming
                        switch (type) {
                                case BT_EVENT:
                                        if (count >= HCI_EVENT_HDR_SIZE) {
                                                struct hci_event_header* headerPacket
                                                        = (struct hci_event_header*)data;
                                                bluetoothDevice->fExpectedPacketSize[type]
                                                        = HCI_EVENT_HDR_SIZE + headerPacket->elen;

                                                if (count >= bluetoothDevice->fExpectedPacketSize[type]) {
                                                        // the whole packet is here so it can be already posted.
                                                        ERROR("%s: EVENT posted in HCI!!!\n", __func__);
                                                        btCoreData->PostEvent(bluetoothDevice, data,
                                                                bluetoothDevice->fExpectedPacketSize[type]);

                                                } else {
                                                        nbuf = gBufferModule->create(
                                                                bluetoothDevice->fExpectedPacketSize[type]);
                                                        bluetoothDevice->fBuffersRx[type] = nbuf;

                                                        nbuf->protocol = type;
                                                }

                                        } else {
                                                panic("EVENT frame corrupted\n");
                                                return EILSEQ;
                                        }
                                        break;

                                case BT_ACL:
                                        if (count >= HCI_ACL_HDR_SIZE) {
                                                struct hci_acl_header* headerPkt = (struct hci_acl_header*)data;

                                                bluetoothDevice->fExpectedPacketSize[type] = HCI_ACL_HDR_SIZE
                                                        + B_LENDIAN_TO_HOST_INT16(headerPkt->alen);

                                                // Create the buffer -> TODO: this allocation can fail
                                                nbuf = gBufferModule->create(
                                                        bluetoothDevice->fExpectedPacketSize[type]);
                                                bluetoothDevice->fBuffersRx[type] = nbuf;

                                                nbuf->protocol = type;
                                        } else {
                                                panic("ACL frame corrupted\n");
                                                return EILSEQ;
                                        }
                                        break;

                                case BT_SCO:

                                        break;

                                default:
                                        panic("unknown packet type in assembly");
                                        break;
                        }

                        currentPacketLen = bluetoothDevice->fExpectedPacketSize[type];

                } else {
                        // Continuation of a packet
                        currentPacketLen = bluetoothDevice->fExpectedPacketSize[type] - nbuf->size;
                }
                if (nbuf != NULL) {
                        currentPacketLen = min_c(currentPacketLen, count);

                        gBufferModule->append(nbuf, data, currentPacketLen);

                        if ((bluetoothDevice->fExpectedPacketSize[type] - nbuf->size) == 0) {

                                switch (nbuf->protocol) {
                                        case BT_EVENT:
                                                panic("need to send full buffer to btdatacore!\n");
                                                btCoreData->PostEvent(bluetoothDevice, data,
                                                        bluetoothDevice->fExpectedPacketSize[type]);

                                                break;
                                        case BT_ACL:
                                                // TODO: device descriptor has been fetched better not
                                                // pass id again
                                                TRACE("%s: ACL parsed in ACL!\n", __func__);
                                                AclAssembly(nbuf, bluetoothDevice->index);
                                                break;
                                        default:

                                                break;
                                }

                                bluetoothDevice->fBuffersRx[type] = nbuf = NULL;
                                bluetoothDevice->fExpectedPacketSize[type] = 0;
                        } else {
                                if (type == BT_ACL) {
                                        TRACE("%s: ACL Packet not filled size %" B_PRIu32
                                                " expected=%" B_PRIuSIZE "\n", __func__, nbuf->size,
                                                bluetoothDevice->fExpectedPacketSize[type]);
                                }
                        }

                }
                // in case in the pipe there is info about the next buffer
                count -= currentPacketLen;
                data = (void*)((uint8*)data + currentPacketLen);
        }

        return B_OK;
}


status_t
HciPacketHandler(void* data, int32 code, size_t size)
{
        hci_id deviceId = Bluetooth::CodeHandler::Device(code);

        bluetooth_device* bluetoothDevice = FindDeviceByID(deviceId);

        TRACE("%s: to assemble %" B_PRIuSIZE " bytes of 0x%" B_PRIx32 "\n",
                __func__, size, deviceId);

        if (bluetoothDevice != NULL) {
                return Assemble(bluetoothDevice, Bluetooth::CodeHandler::Protocol(code),
                        data, size);
        } else {
                ERROR("%s: Device 0x%" B_PRIx32 " could not be matched\n", __func__,
                        deviceId);
        }

        return B_ERROR;
}


//      #pragma mark -


status_t
RegisterDriver(bt_hci_transport_hooks* hooks, bluetooth_device** _device)
{

        bluetooth_device* device = new (std::nothrow) bluetooth_device;
        if (device == NULL)
                return B_NO_MEMORY;

        for (int index = 0; index < HCI_NUM_PACKET_TYPES; index++) {
                device->fBuffersRx[index] = NULL;
                device->fExpectedPacketSize[index] = 0;
        }

        device->info = NULL; // not yet used
        device->hooks = hooks;
        device->supportedPacketTypes = (HCI_DM1 | HCI_DH1 | HCI_HV1);
        device->linkMode = (HCI_LM_ACCEPT);
        device->mtu = L2CAP_MTU_MINIMUM; // TODO: ensure specs min value

        MutexLocker _(&sListLock);

        if (sDeviceList.IsEmpty())
                device->index = HCI_DEVICE_INDEX_OFFSET; // REVIEW: dev index
        else {
                device->index = (sDeviceList.Tail())->index + 1; // REVIEW!
                TRACE("%s: List not empty\n", __func__);
        }

        sDeviceList.Add(device);

        TRACE("%s: Device %" B_PRIx32 "\n", __func__, device->index);

        *_device = device;

        return B_OK;
}


status_t
UnregisterDriver(hci_id id)
{
        bluetooth_device* device = FindDeviceByID(id);

        if (device == NULL)
                return B_ERROR;

        if (device->GetDoublyLinkedListLink()->next != NULL
                || device->GetDoublyLinkedListLink()->previous != NULL
                || device == sDeviceList.Head())
                sDeviceList.Remove(device);

        delete device;

        return B_OK;
}


// PostACL
status_t
PostACL(hci_id hciId, net_buffer* buffer)
{
        net_buffer* curr_frame = NULL;
        net_buffer* next_frame = buffer;
        uint8 flag = HCI_ACL_PACKET_START;

        if (buffer == NULL)
                panic("passing null buffer");

        uint16 handle = buffer->type; // TODO: CodeHandler

        bluetooth_device* device = FindDeviceByID(hciId);

        if (device == NULL) {
                ERROR("%s: No device 0x%" B_PRIx32 "\n", __func__, hciId);
                return B_ERROR;
        }

        TRACE("%s: index 0x%" B_PRIx32 " try to send bt packet of %" B_PRIu32
                " bytes (flags 0x%" B_PRIx32 "):\n", __func__, device->index,
                buffer->size, buffer->flags);

        // TODO: ATOMIC! any other thread should stop here
        do {
                // Divide packet if big enough
                curr_frame = next_frame;

                if (curr_frame->size > device->mtu) {
                        next_frame = gBufferModule->split(curr_frame, device->mtu);
                } else {
                        next_frame = NULL;
                }

                // Attach acl header
                {
                        NetBufferPrepend<struct hci_acl_header> bufferHeader(curr_frame);
                        status_t status = bufferHeader.Status();
                        if (status < B_OK) {
                                // free the buffer
                                continue;
                        }

                        bufferHeader->handle = pack_acl_handle_flags(handle, flag, 0);
                        bufferHeader->alen = curr_frame->size - sizeof(struct hci_acl_header);
                }

                // Send to driver
                curr_frame->protocol = BT_ACL;

                TRACE("%s: Tolower nbuf %p!\n", __func__, curr_frame);
                // We could pass a cookie and avoid the driver fetch the Id
                device->hooks->SendACL(device->index, curr_frame);
                flag = HCI_ACL_PACKET_FRAGMENT;

        } while (next_frame != NULL);

        return B_OK;
}


status_t
PostSCO(hci_id hciId, net_buffer* buffer)
{
        return B_ERROR;
}


status_t
PostESCO(hci_id hciId, net_buffer* buffer)
{
        return B_ERROR;
}


static int
dump_bluetooth_devices(int argc, char** argv)
{
        bluetooth_device*       device;

        DoublyLinkedList<bluetooth_device>::Iterator iterator
                = sDeviceList.GetIterator();

        while (iterator.HasNext()) {
                device = iterator.Next();
                kprintf("\tindex=%" B_PRIx32 " @%p hooks=%p\n", device->index,
                        device, device->hooks);
        }

        return 0;
}


static status_t
bluetooth_std_ops(int32 op, ...)
{
        switch (op) {
                case B_MODULE_INIT:
                {
                        status_t status;

                        status = get_module(NET_BUFFER_MODULE_NAME,
                                (module_info**)&gBufferModule);

                        if (status < B_OK) {
                                panic("no way Dude we need that!");
                                return status;
                        }

                        status = get_module(BT_CORE_DATA_MODULE_NAME,
                                (module_info**)&btCoreData);
                        if (status < B_OK) {
                                ERROR("%s: problem getting bt core data module\n", __func__);
                                return status;
                        }

                        new (&sDeviceList) DoublyLinkedList<bluetooth_device>;
                                // static C++ objects are not initialized in the module startup

                        BluetoothRXPort = new BluetoothRawDataPort(BT_RX_PORT_NAME,
                                (BluetoothRawDataPort::port_listener_func)&HciPacketHandler);

                        if (BluetoothRXPort->Launch() != B_OK) {
                                ERROR("%s: RX thread creation failed!\n", __func__);
                                // we Cannot do much here ... avoid registering
                        } else {
                                TRACE("%s: RX thread launched!\n", __func__);
                        }

                        sLinkChangeSemaphore = create_sem(0, "bt sem");
                        if (sLinkChangeSemaphore < B_OK) {
                                put_module(NET_STACK_MODULE_NAME);
                                ERROR("%s: Link change semaphore failed\n", __func__);
                                return sLinkChangeSemaphore;
                        }

                        mutex_init(&sListLock, "bluetooth devices");

                        // status = InitializeAclConnectionThread();
                        ERROR("%s: Connection Thread error\n", __func__);

                        add_debugger_command("btLocalDevices", &dump_bluetooth_devices,
                                "Lists Bluetooth LocalDevices registered in the Stack");

                        return B_OK;
                }

                case B_MODULE_UNINIT:
                {
                        delete_sem(sLinkChangeSemaphore);

                        mutex_destroy(&sListLock);
                        put_module(NET_BUFFER_MODULE_NAME);
                        put_module(NET_STACK_MODULE_NAME);
                        put_module(BT_CORE_DATA_MODULE_NAME);
                        remove_debugger_command("btLocalDevices", &dump_bluetooth_devices);
                        // status_t status = QuitAclConnectionThread();

                        return B_OK;
                }

                default:
                        return B_ERROR;
        }
}


bt_hci_module_info sBluetoothModule = {
        {
                BT_HCI_MODULE_NAME,
                B_KEEP_LOADED,
                bluetooth_std_ops
        },
        RegisterDriver,
        UnregisterDriver,
        FindDeviceByID,
        PostTransportPacket,
        PostACL,
        PostSCO,
        PostESCO
};


module_info* modules[] = {
        (module_info*)&sBluetoothModule,
        NULL
};