// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#include "BluetoothWorker.hpp"
#include "Device.hpp"
#include "Service/Bus.hpp"
#include <Bluetooth/Device.hpp>
#include <Bluetooth/Error.hpp>
#include <log/log.hpp>
#include <service-bluetooth/BluetoothMessage.hpp>
#include <vector>

extern "C"
{
#include "btstack.h"
#include "hci.h"
};

btstack_packet_callback_registration_t cb_handler;

std::vector<Devicei> devices;

static auto start_scan() -> int;
static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);

static auto getDeviceIndexForAddress(std::vector<Devicei> &devs, bd_addr_t addr) -> int
{
    int j;
    for (j = 0; j < devs.size(); j++) {
        if (bd_addr_cmp(addr, devs[j].address) == 0) {
            return j;
        }
    }
    return -1;
}

enum STATE
{
    INIT,
    ACTIVE,
    DONE
};
enum STATE state = INIT;

namespace Bt::GAP
{
    static sys::Service *ownerService = nullptr;

    void setOwnerService(sys::Service *service)
    {
        ownerService = service;
    }

    auto register_scan() -> Error
    {
        LOG_INFO("GAP register scan!");
        /// -> this have to be called prior to power on!
        hci_set_inquiry_mode(INQUIRY_MODE_RSSI_AND_EIR);
        cb_handler.callback = &packet_handler;
        hci_add_event_handler(&cb_handler);
        return Error();
    }

    auto scan() -> Error
    {
        LOG_INFO("Start scan if active: %d: %d", hci_get_state(), state);
        if (hci_get_state() == HCI_STATE_WORKING) {
            if (int ret = start_scan(); ret != 0) {
                LOG_ERROR("Start scan error!: 0x%X", ret);
                return Error(Error::LibraryError, ret);
            }
        }
        else {
            return Error(Error::NotReady);
        }
        return Error();
    }

    void stop_scan()
    {
        gap_inquiry_force_stop();
        LOG_INFO("Scan stopped!");
    }

    auto set_visibility(bool visibility) -> Error
    {
        gap_discoverable_control(static_cast<uint8_t>(visibility));
        LOG_INFO("Visibility: %s", visibility ? "true" : "false");
        return Error();
    }

    auto do_pairing(uint8_t *addr) -> bool
    {
        if (hci_get_state() == HCI_STATE_WORKING) {
            gap_dedicated_bonding(addr, 0);
            return true;
        }
        return false;
    }
} // namespace Bt::GAP

#define INQUIRY_INTERVAL 5
static auto start_scan() -> int
{
    LOG_INFO("Starting inquiry scan..");
    return gap_inquiry_start(INQUIRY_INTERVAL);
}

static auto has_more_remote_name_requests() -> int
{
    int i;
    for (i = 0; i < devices.size(); i++) {
        if (devices[i].state == REMOTE_NAME_REQUEST) {
            return 1;
        }
    }
    return 0;
}

static void do_next_remote_name_request()
{
    int i;
    for (i = 0; i < devices.size(); i++) {
        // remote name request
        if (devices[i].state == REMOTE_NAME_REQUEST) {
            devices[i].state = REMOTE_NAME_INQUIRED;
            LOG_INFO("Get remote name of %s...", bd_addr_to_str(devices[i].address));
            gap_remote_name_request(
                devices[i].address, devices[i].pageScanRepetitionMode, devices[i].clockOffset | 0x8000);
            return;
        }
    }
}

static void continue_remote_names()
{
    if (has_more_remote_name_requests() != 0) {
        do_next_remote_name_request();
        return;
    }
    start_scan();
}

static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)
{
    UNUSED(channel);
    UNUSED(size);

    bd_addr_t addr;
    int i;
    int index;

    if (packet_type != HCI_EVENT_PACKET) {
        return;
    }

    uint8_t event = hci_event_packet_get_type(packet);

    switch (state) {
        /* @text In INIT, an inquiry  scan is started, and the application transits to
         * ACTIVE state.
         */
    case INIT:
        switch (event) {
        case BTSTACK_EVENT_STATE:
            if (btstack_event_state_get_state(packet) == HCI_STATE_WORKING) {
                state = ACTIVE;
            }
            break;
        default:
            break;
        }
        break;

        /* @text In ACTIVE, the following events are processed:
         *  - GAP Inquiry result event: BTstack provides a unified inquiry result that contain
         *    Class of Device (CoD), page scan mode, clock offset. RSSI and name (from EIR) are optional.
         *  - Inquiry complete event: the remote name is requested for devices without a fetched
         *    name. The state of a remote name can be one of the following:
         *    REMOTE_NAME_REQUEST, REMOTE_NAME_INQUIRED, or REMOTE_NAME_FETCHED.
         *  - Remote name request complete event: the remote name is stored in the table and the
         *    state is updated to REMOTE_NAME_FETCHED. The query of remote names is continued.
         */
    case ACTIVE:
        switch (event) {

        case GAP_EVENT_INQUIRY_RESULT: {
            gap_event_inquiry_result_get_bd_addr(packet, addr);
            index = getDeviceIndexForAddress(devices, addr);
            if (index >= 0) {
                break; // already in our list
            }

            Devicei dev;
            dev.address_set(&addr);
            dev.pageScanRepetitionMode = gap_event_inquiry_result_get_page_scan_repetition_mode(packet);
            dev.clockOffset            = gap_event_inquiry_result_get_clock_offset(packet);
            // print info
            LOG_INFO("Device found: %s ", bd_addr_to_str(addr));
            LOG_INFO("with COD: 0x%06x, ", (unsigned int)gap_event_inquiry_result_get_class_of_device(packet));
            LOG_INFO("pageScan %d, ", dev.pageScanRepetitionMode);
            LOG_INFO("clock offset 0x%04x", dev.clockOffset);
            if (gap_event_inquiry_result_get_rssi_available(packet) != 0u) {
                LOG_INFO(", rssi %d dBm", (int8_t)gap_event_inquiry_result_get_rssi(packet));
            }
            if (gap_event_inquiry_result_get_name_available(packet) != 0u) {
                char name_buffer[240];
                int name_len = gap_event_inquiry_result_get_name_len(packet);
                memcpy(name_buffer, gap_event_inquiry_result_get_name(packet), name_len);
                name_buffer[name_len] = 0;
                LOG_INFO(", name '%s'", name_buffer);
                dev.name  = std::string{name_buffer};
                dev.state = REMOTE_NAME_FETCHED;
            }
            else {
                dev.state = REMOTE_NAME_REQUEST;
            }
            devices.push_back(dev);
            auto msg = std::make_shared<BluetoothScanResultMessage>(devices);
            sys::Bus::SendUnicast(msg, "ApplicationSettings", Bt::GAP::ownerService);
            sys::Bus::SendUnicast(msg, "ApplicationSettingsNew", Bt::GAP::ownerService);

        } break;

        case GAP_EVENT_INQUIRY_COMPLETE:
            for (i = 0; i < devices.size(); i++) {
                // retry remote name request
                if (devices[i].state == REMOTE_NAME_INQUIRED)
                    devices[i].state = REMOTE_NAME_REQUEST;
            }
            continue_remote_names();
            break;

        case HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE: {
            reverse_bd_addr(&packet[3], addr);
            index = getDeviceIndexForAddress(devices, addr);
            if (index >= 0) {
                if (packet[2] == 0) {
                    LOG_INFO("Name: '%s'", &packet[9]);
                    devices[index].state = REMOTE_NAME_FETCHED;
                    devices[index].name  = reinterpret_cast<char *>(&packet[9]);
                }
                else {
                    LOG_INFO("Failed to get name: page timeout");
                }
            }
            if (index + 1 == devices.size()) {
                LOG_INFO("Scanned all");
                state = DONE;
                gap_inquiry_stop();
                break;
            }
            continue_remote_names();
        } break;
        case GAP_EVENT_DEDICATED_BONDING_COMPLETED: {
            auto result = packet[2];
            auto msg    = std::make_shared<BluetoothPairResultMessage>(result == 0u);
            sys::Bus::SendUnicast(msg, "ApplicationSettings", Bt::GAP::ownerService);
            sys::Bus::SendUnicast(msg, "ApplicationSettingsNew", Bt::GAP::ownerService);
        } break;
        default:
            break;
        }
        break;

    default:
        break;
    }
}