// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
library fuchsia.bluetooth.test;

using fuchsia.bluetooth as bt;
using fuchsia.bluetooth.bredr as bredr;

/// Error codes that can be generated for emulator-wide configurations.
type EmulatorError = strict enum {
    FAILED = 1;
    HCI_ALREADY_PUBLISHED = 2;
};

/// Error codes that are generated for functions that manipulate fake peers.
type EmulatorPeerError = strict enum {
    ADDRESS_REPEATED = 1;
    PARAMETERS_INVALID = 2;
    NOT_FOUND = 3;
};

// TODO(fxbug.dev/822): Add state structures for other LE and BR/EDR operations.
// TODO(armansito): Add ability to publish GATT services
// TODO(armansito): Add ability to publish SDP records
// TODO(armansito): Add ability to specify Bluetooth HCI version.

/// Pre-set HCI configurations.
type HciConfig = strict enum {
    /// Support both BR/EDR and LE in LMP features.
    DUAL_MODE = 1;

    /// Limits supported features and HCI commands to those that are required for LE only.
    LE_ONLY = 2;
};

/// The HCI ACL data flow-control parameters.
type AclBufferSettings = struct {
    /// ACL frame MTU in bytes.
    data_packet_length uint16;

    /// The maximum number of ACL frames that the controller can buffer.
    total_num_data_packets uint8;
};

/// Controller settings used by the emulator.
type EmulatorSettings = table {
    /// The `BD_ADDR` (BR/EDR) or LE Public Device Address. Defaults to "00:00:00:00:00:00".
    1: address bt.Address;

    /// Supported HCI command configuration. Defaults to "`DUAL_MODE`".
    2: hci_config HciConfig;

    /// True if the 5.0 extended advertising features are supported. Defaults to "false".
    3: extended_advertising bool;

    /// The ACL-U data buffer settings. Defaults to
    ///    data_packet_length: 1024
    ///    total_num_data_packets: 5
    /// IF `hci_config` is set to `DUAL_MODE`. Defaults to null otherwise.
    4: acl_buffer_settings AclBufferSettings;

    /// The LE-U ACL data buffer settings. Defaults to
    ///    data_packet_length: 251
    ///    total_num_data_packets: 5
    5: le_acl_buffer_settings AclBufferSettings;
};

type AdvertisingData = struct {
    data vector<uint8>:MAX_LEGACY_ADVERTISING_DATA_LENGTH;
};

/// Parameters used to emulate a peer's behavior over the Low Energy transport.
type LowEnergyPeerParameters = table {
    /// The LE identity address of the peer. This field is mandatory.
    1: address bt.Address;

    /// When present and true, the peer will send connectable advertisements and accept connection
    /// requests. The peer will ignore connection requests if not connectable.
    2: connectable bool;

    /// The advertising data contents. If not present, the advertising data sent by this peer will
    /// be empty.
    3: advertisement AdvertisingData;

    /// The scan response data contents. When present, the fake controller will generate scannable
    /// advertising packets and scan response events.
    4: scan_response AdvertisingData;
};

/// Maximum service records that can be advertised at once.
const MAX_PEER_SERVICES uint8 = 32;

/// Parameters used to emulate a peer's behavior over the BR/EDR transport.
type BredrPeerParameters = table {
    /// The BD_ADDR of the peer. This field is mandatory.
    1: address bt.Address;

    /// When present and true, the peer will accept connection requests. The peer will ignore
    /// connection requests if not connectable.
    2: connectable bool;

    /// The device class reported in the inquiry response for this peer during device discovery.
    3: device_class bt.DeviceClass;

    // The peer's services that will be discoverable via Service Discovery Protocol.
    4: service_definition vector<bredr.ServiceDefinition>:MAX_PEER_SERVICES;
};

type ConnectionState = strict enum {
    CONNECTED = 1;
    DISCONNECTED = 2;
};

/// Protocol used to drive the state of a fake peer device.
protocol Peer {
    /// Assign a HCI `status` for the controller to generate in response to connection requests.
    /// Applies to all successive HCI_Create_Connection and HCI_LE_Create_Connection commands. The
    /// procedure is acknowledged with an empty response.
    AssignConnectionStatus(struct {
        status HciError;
    }) -> ();

    /// Emulates a LE connection event. Does nothing if the peer is already connected. The
    /// `role` parameter determines the link layer connection role.
    EmulateLeConnectionComplete(struct {
        role bt.ConnectionRole;
    });

    /// Emulate disconnection. Does nothing if the peer is not connected.
    EmulateDisconnectionComplete();

    /// Watch connection state changes using the
    /// [hanging get pattern](https://fuchsia.dev/fuchsia-src/concepts/api/fidl#delay-responses-using-hanging-gets).
    /// Notifies the most recent controller connection state if there has been a change since the
    /// last time this method was called.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the connection state.
    WatchConnectionStates() -> (struct {
        states vector<ConnectionState>:MAX;
    });
};

/// Protocol used to emulate a Bluetooth controller that supports the standard Bluetooth HCI.
@discoverable
protocol HciEmulator {
    /// Publish a bt-hci device using the provided `settings`. Each HciEmulator instance can only
    /// manage a single bt-hci device. Returns Emulator.`HCI_ALREADY_PUBLISHED` if the device has
    /// already been published.
    Publish(struct {
        settings EmulatorSettings;
    }) -> (struct {}) error EmulatorError;

    /// Inserts a new LE peer device to be emulated by this controller. Once registered, the state
    /// of the fake peer can be driven and observed using the `peer` handle.
    ///
    /// A reply will be sent to acknowledge the creation of the fake peer. If a peer cannot be
    /// initialized (e.g. due to a missing required field in `parameters` or for containing an
    /// address that is already emulated) the `peer` handle will be closed and an error reply will
    /// be sent.
    ///
    /// The peer will appear in advertising reports and respond to requests according to its
    /// configuration as long as the `peer` channel is open. The emulator stops emulating this peer
    /// when the channel gets closed, which makes it no longer discoverable and not respond to any
    /// requests.
    AddLowEnergyPeer(resource struct {
        parameters LowEnergyPeerParameters;
        peer server_end:Peer;
    }) -> (struct {}) error EmulatorPeerError;

    /// Inserts a new BR/EDR peer device to be emulated by this controller. Once registered, the state
    /// of the fake peer can be driven and observed using the `peer` handle.
    ///
    /// A reply will be sent to acknowledge the creation of the fake peer. If a peer cannot be
    /// initialized (e.g. due to a missing required field in `parameters` or for containing an
    /// address that is already emulated) the `peer` handle will be closed and an error reply will
    /// be sent.
    ///
    /// The peer will appear in inquiry results and respond to requests according to its
    /// configuration as long as the `peer` channel is open. The emulator stops emulating this peer
    /// when the channel gets closed, which makes it no longer discoverable and not respond to any
    /// requests.
    AddBredrPeer(resource struct {
        parameters BredrPeerParameters;
        peer server_end:Peer;
    }) -> (struct {}) error EmulatorPeerError;

    /// Returns the current controller parameter state. If the parameters have not changed since the
    /// last time this message was received, then this method does not return until there is a
    /// change.
    /// (see [hanging get pattern](https://fuchsia.dev/fuchsia-src/concepts/api/fidl#delay-responses-using-hanging-gets))
    WatchControllerParameters() -> (struct {
        parameters ControllerParameters;
    });

    /// Returns the most recent set of state transitions for the link layer LE scan procedure. This
    /// method returns when there has been a state change since the last invocation of this method
    /// by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    /// (see [hanging get pattern](https://fuchsia.dev/fuchsia-src/concepts/api/fidl#delay-responses-using-hanging-gets))
    WatchLeScanStates() -> (struct {
        states vector<LeScanState>:MAX;
    });

    /// Returns the most recent set of state transitions for the link layer LE legacy advertising
    /// procedure. This method returns when there has been a state change since the last invocation
    /// of this method by this client.
    ///
    /// Only one call to this method can be outstanding at a given time. The
    /// [`fuchsia.bluetooth.test/HciEmulator`] channel will be closed if a call received when one is
    /// already pending.
    /// (see [hanging get pattern](https://fuchsia.dev/fuchsia-src/concepts/api/fidl#delay-responses-using-hanging-gets))
    WatchLegacyAdvertisingStates() -> (struct {
        states vector<LegacyAdvertisingState>:MAX;
    });
};