#ifndef SSP_IO_CAPABILITIES_H
#define SSP_IO_CAPABILITIES_H

#include <stdint.h>

/*
 * HCI I/O Capability values (Bluetooth Core Spec Vol 2, Part C, 5.2.1)
 * Used in HCI_IO_Capability_Request_Reply command.
 */
#define IO_CAP_DISPLAY_ONLY       0x00  /* e.g. BT speaker with LED display */
#define IO_CAP_DISPLAY_YES_NO     0x01  /* e.g. Phone, Laptop               */
#define IO_CAP_KEYBOARD_ONLY      0x02  /* e.g. BT keyboard (no screen)     */
#define IO_CAP_NO_INPUT_NO_OUTPUT 0x03  /* e.g. Mono headset                */
#define IO_CAP_KEYBOARD_DISPLAY   0x04  /* e.g. Full smartphone             */

/*
 * OOB Data Present field
 */
#define OOB_DATA_NOT_PRESENT  0x00
#define OOB_DATA_FROM_REMOTE  0x01

/*
 * Authentication Requirements
 * Bit 2 = MITM protection required (1 = yes)
 * Bit 0 = Dedicated bonding (vs general bonding)
 */
#define AUTH_REQ_NO_BONDING_NO_MITM   0x00
#define AUTH_REQ_BONDING_NO_MITM      0x02
#define AUTH_REQ_NO_BONDING_MITM      0x04
#define AUTH_REQ_BONDING_MITM         0x05

/*
 * Association model selected based on I/O capability negotiation.
 * Use ssp_select_model() to determine this at runtime.
 */
typedef enum {
    SSP_MODEL_NUMERIC_COMPARISON = 0,
    SSP_MODEL_JUST_WORKS,
    SSP_MODEL_OUT_OF_BAND,
    SSP_MODEL_PASSKEY_ENTRY,
    SSP_MODEL_UNKNOWN
} ssp_model_t;

typedef struct {
    uint8_t io_capability;   /* One of IO_CAP_* above            */
    uint8_t oob_present;     /* OOB_DATA_NOT_PRESENT or _PRESENT  */
    uint8_t auth_req;        /* AUTH_REQ_* flags                  */
} ssp_io_cap_t;

#endif /* SSP_IO_CAPABILITIES_H */

#include <stdio.h>
#include "ssp_io_capabilities.h"

/*
 * ssp_select_model()
 *
 * Implements the SSP association model selection table from
 * Bluetooth Core Spec Vol 2, Part C, Section 5.2.2.6.
 *
 * Returns the association model to use based on the combined
 * I/O capabilities of both devices.
 */
ssp_model_t ssp_select_model(const ssp_io_cap_t *local,
                              const ssp_io_cap_t *remote)
{
    /* OOB takes priority if both sides have OOB data */
    if (local->oob_present  == OOB_DATA_FROM_REMOTE ||
        remote->oob_present == OOB_DATA_FROM_REMOTE) {
        return SSP_MODEL_OUT_OF_BAND;
    }

    /*
     * If neither side requires MITM, Just Works is used
     * when the combined capability would normally give Numeric
     * Comparison or Passkey Entry — saves user effort.
     */
    uint8_t mitm_required = (local->auth_req  & 0x04) ||
                            (remote->auth_req & 0x04);

    uint8_t l = local->io_capability;
    uint8_t r = remote->io_capability;

    /*
     * Table lookup: rows = local IO cap, columns = remote IO cap
     * Values: N=NumericComparison, J=JustWorks, P=Passkey
     *
     *                   Remote
     *              DOnly  DYN  KOnly  NINO  KD
     * Local DOnly:   J     N     P     J    P
     * Local DYN  :   N     N     P     J    N
     * Local KOnly:   P     P     P     J    P
     * Local NINO :   J     J     J     J    J
     * Local KD   :   P     N     P     J    N
     */

    /* NINO (no input, no output) always gives Just Works */
    if (l == IO_CAP_NO_INPUT_NO_OUTPUT ||
        r == IO_CAP_NO_INPUT_NO_OUTPUT) {
        return SSP_MODEL_JUST_WORKS;
    }

    /* Determine if Passkey Entry applies */
    int local_has_display = (l == IO_CAP_DISPLAY_ONLY     ||
                              l == IO_CAP_DISPLAY_YES_NO   ||
                              l == IO_CAP_KEYBOARD_DISPLAY);

    int remote_has_input  = (r == IO_CAP_KEYBOARD_ONLY    ||
                              r == IO_CAP_KEYBOARD_DISPLAY);

    int remote_has_display = (r == IO_CAP_DISPLAY_ONLY    ||
                               r == IO_CAP_DISPLAY_YES_NO  ||
                               r == IO_CAP_KEYBOARD_DISPLAY);

    int local_has_input   = (l == IO_CAP_KEYBOARD_ONLY    ||
                              l == IO_CAP_KEYBOARD_DISPLAY);

    /* Numeric Comparison: both sides have display + yes/no capability */
    if ((l == IO_CAP_DISPLAY_YES_NO || l == IO_CAP_KEYBOARD_DISPLAY) &&
        (r == IO_CAP_DISPLAY_YES_NO || r == IO_CAP_KEYBOARD_DISPLAY)) {
        return SSP_MODEL_NUMERIC_COMPARISON;
    }

    /* Passkey Entry: one side has display, other has keyboard */
    if ((local_has_display && remote_has_input) ||
        (local_has_input   && remote_has_display)) {
        return SSP_MODEL_PASSKEY_ENTRY;
    }

    /*
     * If MITM is not required, fall back to Just Works even if
     * Numeric Comparison capability exists.
     */
    if (!mitm_required) {
        return SSP_MODEL_JUST_WORKS;
    }

    return SSP_MODEL_JUST_WORKS; /* fallback */
}

const char *ssp_model_name(ssp_model_t model)
{
    switch (model) {
    case SSP_MODEL_NUMERIC_COMPARISON: return "Numeric Comparison";
    case SSP_MODEL_JUST_WORKS:         return "Just Works";
    case SSP_MODEL_OUT_OF_BAND:        return "Out of Band (OOB)";
    case SSP_MODEL_PASSKEY_ENTRY:      return "Passkey Entry";
    default:                           return "Unknown";
    }
}

/* -------------------------------------------------------
 * Handle an incoming HCI_IO_Capability_Request event.
 * The host must reply with local I/O capabilities.
 * ------------------------------------------------------- */
void handle_io_cap_request(int hci_fd, const uint8_t *bd_addr)
{
    /*
     * HCI_IO_Capability_Request_Reply command
     *   OGF  = 0x01 (Link Control)
     *   OCF  = 0x002B
     *
     * Parameters:
     *   BD_ADDR       [6 bytes]
     *   IO_Capability [1 byte]  — advertise our capability
     *   OOB_Data_Present [1 byte]
     *   Authentication_Requirements [1 byte]
     */
    printf("[SSP] IO_Capability_Request received\n");
    printf("[SSP] Replying with: DisplayYesNo, NoOOB, MITM required\n");

    /*
     * In a real BlueZ-based implementation you would call:
     *   hci_send_cmd(hci_fd, OGF_LINK_CTL, 0x002B, params_len, params)
     *
     * Here we just show the parameter values for illustration.
     */
    uint8_t params[9];
    memcpy(params, bd_addr, 6);
    params[6] = IO_CAP_DISPLAY_YES_NO;    /* local I/O capability  */
    params[7] = OOB_DATA_NOT_PRESENT;     /* no NFC OOB data       */
    params[8] = AUTH_REQ_BONDING_MITM;    /* require MITM + bond   */

    printf("[SSP] Params: IO_CAP=0x%02X OOB=0x%02X AUTH=0x%02X\n",
           params[6], params[7], params[8]);
}

/* -------------------------------------------------------
 * Handle Numeric Comparison: compare and auto-confirm.
 * In a real product this would drive a UI prompt.
 * ------------------------------------------------------- */
void handle_user_confirmation_request(const uint8_t *bd_addr,
                                      uint32_t numeric_value)
{
    printf("[SSP] User Confirmation Request\n");
    printf("[SSP] Remote BD_ADDR: %02X:%02X:%02X:%02X:%02X:%02X\n",
           bd_addr[5], bd_addr[4], bd_addr[3],
           bd_addr[2], bd_addr[1], bd_addr[0]);
    printf("[SSP] Numeric Value on both screens: %06u\n", numeric_value);
    printf("[SSP] → Show this to user; send Positive Reply if they confirm\n");

    /*
     * HCI_User_Confirmation_Request_Positive_Reply (OCF=0x002C)
     * or HCI_User_Confirmation_Request_Negative_Reply (OCF=0x002D)
     * depending on user input.
     */
}

/* -------------------------------------------------------
 * Handle Passkey Request: display passkey to user.
 * ------------------------------------------------------- */
void handle_passkey_display(const uint8_t *bd_addr, uint32_t passkey)
{
    printf("[SSP] Passkey Notification\n");
    printf("[SSP] Display this code to user: %06u\n", passkey);
    printf("[SSP] User must type this on the remote device keyboard\n");
}

int main(void)
{
    printf("=== SSP Association Model Selection Demo ===\n\n");

    /* Scenario 1: Phone (DisplayYesNo) + Laptop (DisplayYesNo) */
    ssp_io_cap_t phone  = { IO_CAP_DISPLAY_YES_NO, OOB_DATA_NOT_PRESENT, AUTH_REQ_BONDING_MITM };
    ssp_io_cap_t laptop = { IO_CAP_DISPLAY_YES_NO, OOB_DATA_NOT_PRESENT, AUTH_REQ_BONDING_MITM };
    printf("Phone + Laptop   → %s\n",
           ssp_model_name(ssp_select_model(&phone, &laptop)));

    /* Scenario 2: Phone (DisplayYesNo) + Headset (NINO) */
    ssp_io_cap_t headset = { IO_CAP_NO_INPUT_NO_OUTPUT, OOB_DATA_NOT_PRESENT, AUTH_REQ_NO_BONDING_NO_MITM };
    printf("Phone + Headset  → %s\n",
           ssp_model_name(ssp_select_model(&phone, &headset)));

    /* Scenario 3: Laptop (DisplayOnly) + BT Keyboard (KeyboardOnly) */
    ssp_io_cap_t pc       = { IO_CAP_DISPLAY_ONLY,   OOB_DATA_NOT_PRESENT, AUTH_REQ_BONDING_MITM };
    ssp_io_cap_t keyboard = { IO_CAP_KEYBOARD_ONLY,  OOB_DATA_NOT_PRESENT, AUTH_REQ_BONDING_MITM };
    printf("Laptop + Keyboard → %s\n",
           ssp_model_name(ssp_select_model(&pc, &keyboard)));

    /* Scenario 4: Both NFC-enabled devices */
    ssp_io_cap_t nfc_a = { IO_CAP_DISPLAY_YES_NO, OOB_DATA_FROM_REMOTE, AUTH_REQ_BONDING_MITM };
    ssp_io_cap_t nfc_b = { IO_CAP_DISPLAY_YES_NO, OOB_DATA_FROM_REMOTE, AUTH_REQ_BONDING_MITM };
    printf("NFC device + NFC device → %s\n",
           ssp_model_name(ssp_select_model(&nfc_a, &nfc_b)));

    return 0;
}

gcc -o ssp_demo ssp_model_select.c
./ssp_demo

# Output:
# Phone + Laptop    → Numeric Comparison
# Phone + Headset   → Just Works
# Laptop + Keyboard → Passkey Entry
# NFC device + NFC  → Out of Band (OOB)