/*
 *
 *    Copyright (c) 2014-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *    @file
 *      This file contains the defined constants and data structures
 *      for WoBle Control Path and Troughput Test
 *
 */

#ifndef WOBLE_TEST_H_
#define WOBLE_TEST_H_

#include <stdio.h>
#include <pthread.h>
#include <SystemLayer/SystemLayer.h>
#include <SystemLayer/SystemTimer.h>

namespace nl {
namespace Ble {

using ::nl::Weave::System::PacketBuffer;

// Forward declarations
class BleLayer;
class BLEEndPoint;

// Definitions of the BLE test command formats and constants
#define COMMAND_VERSION_LEN 1
#define COMMAND_DESTINATIONS_LEN 1
#define COMMAND_TYPE_LEN 1
#define COMMAND_PAYLOAD_LEN 2
#define COMMAND_HEADER_LEN (    COMMAND_PAYLOAD_LEN + \
                                COMMAND_VERSION_LEN + \
                                COMMAND_DESTINATIONS_LEN + \
                                COMMAND_TYPE_LEN )

#define COMMAND_ACK_ACK_LEN 1
#define COMMAND_ACK_SEQUENCE_LEN 1
#define COMMAND_ACK_RESULT_LEN 2
#define COMMAND_ACK_HDR_LEN (   COMMAND_ACK_ACK_LEN + \
                                COMMAND_ACK_SEQUENCE_LEN + \
                                COMMAND_ACK_RESULT_LEN )

#define COMMAND_DATA_TYPE_LEN 1
#define COMMAND_DATA_ACK_LEN 1
#define COMMAND_DATA_LENGTH_LEN 2
#define COMMAND_DATA_SEQUENCE_LEN 4
#define COMMAND_DATA_HDR_LEN (  COMMAND_DATA_TYPE_LEN + \
                                COMMAND_DATA_ACK_LEN + \
                                COMMAND_DATA_LENGTH_LEN + \
                                COMMAND_DATA_SEQUENCE_LEN )

// The total header length(overhead) of a test data packet
#define COMMAND_TESTDATA_HDR_LEN    (COMMAND_HEADER_LEN + COMMAND_DATA_HDR_LEN)

#define COMMAND_TESTREQ_COUNT_LEN 4
#define COMMAND_TESTREQ_DURATION_LEN 4
#define COMMAND_TESTREQ_TXGAP_LEN 2
#define COMMAND_TESTREQ_ACK_LEN 1
#define COMMAND_TESTREQ_SIZE_LEN 2
#define COMMAND_TESTREQ_HDR_LEN (   COMMAND_TESTREQ_COUNT_LEN + \
                                    COMMAND_TESTREQ_DURATION_LEN + \
                                    COMMAND_TESTREQ_TXGAP_LEN + \
                                    COMMAND_TESTREQ_ACK_LEN + \
                                    COMMAND_TESTREQ_SIZE_LEN )

#define COMMAND_TESTRESULT_RESULTOP_LEN 2
#define COMMAND_TESTRESULT_RESULT_LEN 4
#define COMMAND_TESTRESULT_COUNT_LEN 4
#define COMMAND_TESTRESULT_DURATION_LEN 4
#define COMMAND_TESTRESULT_ACKCOUNT_LEN 4
#define COMMAND_TESTRESULT_TXDROPS_LEN 4
#define COMMAND_TESTRESULT_TXGAP_LEN 2
#define COMMAND_TESTRESULT_SIZE_LEN 2
#define COMMAND_TESTRESULT_PKTCOUNT_LEN 2
#define COMMAND_TESTRESULT_TXTIME_LEN 4
#define COMMAND_TESTRESULT_TXTIMEMAX_LEN 2
#define COMMAND_TESTRESULT_TXTIMEMIN_LEN 2
#define COMMAND_TESTRESULT_TXACKCOUNT_LEN 2
#define COMMAND_TESTRESULT_TXACKTIME_LEN 4
#define COMMAND_TESTRESULT_TXACKTIMEMAX_LEN 2
#define COMMAND_TESTRESULT_TXACKTIMEMIN_LEN 2
#define COMMAND_TESTRESULT_TXTIMELAST_LEN 2
#define COMMAND_TESTRESULT_PAYLOADLAST_LEN 2
#define COMMAND_TESTRESULT_PAYLOADBYTES_LEN 4
#define COMMAND_TESTRESULT_HDR_LEN (    COMMAND_TESTRESULT_RESULTOP_LEN + \
                                        COMMAND_TESTRESULT_RESULT_LEN + \
                                        COMMAND_TESTRESULT_COUNT_LEN + \
                                        COMMAND_TESTRESULT_DURATION_LEN + \
                                        COMMAND_TESTRESULT_ACKCOUNT_LEN + \
                                        COMMAND_TESTRESULT_TXGAP_LEN + \
                                        COMMAND_TESTRESULT_TXDROPS_LEN + \
                                        COMMAND_TESTRESULT_SIZE_LEN + \
                                        COMMAND_TESTRESULT_PKTCOUNT_LEN + \
                                        COMMAND_TESTRESULT_TXTIME_LEN + \
                                        COMMAND_TESTRESULT_TXTIMEMAX_LEN + \
                                        COMMAND_TESTRESULT_TXTIMEMIN_LEN + \
                                        COMMAND_TESTRESULT_TXACKCOUNT_LEN + \
                                        COMMAND_TESTRESULT_TXACKTIME_LEN + \
                                        COMMAND_TESTRESULT_TXACKTIMEMAX_LEN + \
                                        COMMAND_TESTRESULT_TXACKTIMEMIN_LEN + \
                                        COMMAND_TESTRESULT_TXTIMELAST_LEN + \
                                        COMMAND_TESTRESULT_PAYLOADLAST_LEN + \
                                        COMMAND_TESTRESULT_PAYLOADBYTES_LEN )

#define COMMAND_WOBLEMTU_OP_LEN 1
#define COMMAND_WOBLEMTU_TXFRAGSIZE_LEN 2
#define COMMAND_WOBLEMTU_RXFRAGSIZE_LEN 2
#define COMMAND_WOBLEMTU_HDR_LEN (      COMMAND_WOBLEMTU_OP_LEN + \
                                        COMMAND_WOBLEMTU_TXFRAGSIZE_LEN + \
                                        COMMAND_WOBLEMTU_RXFRAGSIZE_LEN)

#define COMMAND_WINDOWSIZE_OP_LEN 1
#define COMMAND_WINDOWSIZE_TXWINSIZE_LEN 1
#define COMMAND_WINDOWSIZE_RXWINSIZE_LEN 1
#define COMMAND_WINDOWSIZE_HDR_LEN (    COMMAND_WINDOWSIZE_OP_LEN + \
                                        COMMAND_WINDOWSIZE_TXWINSIZE_LEN + \
                                        COMMAND_WINDOWSIZE_RXWINSIZE_LEN)

#define COMMAND_TXTIMING_ENABLE_LEN 1
#define COMMAND_TXTIMING_HDR_LEN (      COMMAND_TXTIMING_ENABLE_LEN )

enum
{
    kAckType_OK             = 0,
    kAckType_NOK            = 1
};

class BTCommandTypeAck
{
public:
    uint8_t Type;                     // Ack type : 0 = OK, 1 = NOK
    SequenceNumber_t SequenceNumber;  // Acknowledged Packet Sequence Number
    int32_t ResultCode;               // Command Result Code
};

enum
{
    kDataType_CONTINUE      = 0,
    kDataType_START         = 1,
    kDataType_END           = 2,
    kDataType_ABORT         = 3
};

class BTCommandTypeTestData
{
public:
    uint8_t Type;                     // kDataType_xxx
    uint8_t NeedAck;                  // 1 : Ack is required
    uint16_t Length;                  // Packet data length
    uint32_t Sequence;                // Tx sequence number
    uint8_t Data[0];                  // Start of Data
};

class BTCommandTypeTestRequest
{
public:
    uint32_t PacketCount;             // Total Packet Count
    uint32_t Duration;                // Test Duration
    uint16_t TxGap;                   // Gap in ms between packets (min = 1 ms)
    uint8_t NeedAck;                  // Ack is required for each packet
    uint16_t PayloadSize;             // Payload size of each packet (0~2048 bytes)
};

enum
{
    kBleCommandTestResult_Reply         = 0,
    kBleCommandTestResult_Request       = 1,
};

class BTCommandTypeTestResult
{
public:
    uint16_t TestResultOp;          // Test Result Reuest or Reply
    uint32_t TestResult;            // Error or test result code
    uint32_t PacketCount;           // 0 means a request for the last test result
    uint32_t Duration;              // Test Duration
    uint32_t AckCount;              // Received Ack count during the test
    uint32_t TxDrops;               // Dropped Tx packets
    uint16_t TxGap;                 // Gap in ms between packets
    uint16_t PayloadSize;           // Payload Size of each packet (0~2048 bytes)
    uint16_t TxPktCount;            // Total sent WoBle packets
    uint32_t TxTimeMs;              // Total tx duration for the sent test WoBle packets
    uint16_t TxTimeMax;             // Longest Tx duration
    uint16_t TxTimeMin;             // Smallest Tx duration
    uint16_t TxAckCount;            // Total received Ack packets
    uint32_t TxAckTimeMs;           // Total Tx+Ack duration for the sent test WoBle packets
    uint16_t TxAckTimeMax;          // Longest Tx+Ack duration
    uint16_t TxAckTimeMin;          // Smallest Tx+Ack duration
    uint16_t TxTimeLastMs;          // Last Tx duration
    uint16_t PayloadLast;           // Last Payload bytes
    uint32_t PayloadBytes;          // Total Payload bytes
};

enum
{
    kCmdType_Reply  = 0,
    kCmdType_Get    = 1,
    kCmdType_Set    = 2
};

class BTCommandTypeWobleMTU
{
public:
    uint8_t Op;                       // 0 = Reply, 1 = Get, 2 = Set
    uint16_t TxFragmentSize;          // Tx fragment size in bytes
    uint16_t RxFragmentSize;          // Rx fragment size in bytes
};

class BTCommandTypeWindowSize
{
public:
    uint8_t Op;                       // 0 = Reply, 1 = Get, 2 = Set
    uint8_t TxWindowSize;             // unit is packet, 0 means no change
    uint8_t RxWindowSize;             // unit is packet, 0 means no change
};

class BTCommandTypeTxTiming
{
public:
    bool Enable;                      // 0 = disable
};

#define BLE_TEST_DATA_MAX_LEN       1024

#define kBleCommandDest_None    0
#define kBleCommandDest_Local   0x1
#define kBleCommandDest_Remote  0x2

#define BLE_COMMAND_OP_BASE     80
enum
{
    kBleCommandType_TestAck         =   (BLE_COMMAND_OP_BASE + 0),
    kBleCommandType_TestData        =   (BLE_COMMAND_OP_BASE + 1),
    kBleCommandType_TestRequest     =   (BLE_COMMAND_OP_BASE + 2),
    kBleCommandType_TestResult      =   (BLE_COMMAND_OP_BASE + 3),
    kBleCommandType_WobleMTU        =   (BLE_COMMAND_OP_BASE + 4),
    kBleCommandType_WobleWindowSize =   (BLE_COMMAND_OP_BASE + 5),
    kBleCommandType_TxTiming        =   (BLE_COMMAND_OP_BASE + 6)
};

class BTCommandHeader
{
public:
    uint16_t PacketLength;            // Control Packet Length
    uint8_t Version;                  // Control Protocol Version
    uint8_t PacketType;               // Control Packet Type
};

class BleTransportCommandMessage
{
public:
    BTCommandHeader CmdHdr;

    union {
        BTCommandTypeAck            MsgTestAck;
        BTCommandTypeTestData       MsgTestData;
        BTCommandTypeTestRequest    MsgTestRequest;
        BTCommandTypeTestResult     MsgTestResult;
        BTCommandTypeWobleMTU       MsgWobleMTU;
        BTCommandTypeWindowSize     MsgWobleWindowSize;
        BTCommandTypeTxTiming       MsgTxTiming;
    } Payload;

    uint32_t    CommandTest_Duration;
    uint32_t    CommandTest_PacketCount;
    bool        CommandTest_Start;

    uint8_t Data[BLE_TEST_DATA_MAX_LEN];    // Control Packet PayLoad

    // Must be able to reserve 20 byte data length in msgBuf.
    BLE_ERROR Encode(PacketBuffer *msgBuf, BleTransportCommandMessage& msg) const;

    static BLE_ERROR Decode(const PacketBuffer &msgBuf, BleTransportCommandMessage& msg);
};

enum
{
    WOBLE_TX_START      = 0,
    WOBLE_TX_DONE       = 1,
    WOBLE_TX_DATA_ACK   = 2
};

enum
{
    WOBLE_TEST_NONE = 0,
    WOBLE_TEST_TX   = 1,
    WOBLE_TEST_RX   = 2
};

class WoBleTxRecord
{
public:
    uint32_t    TxStart;    // Tx start time : Epoch(ms)
    uint16_t    TxTime;     // Tx time (ms)
    uint16_t    Payload;    // payload in bytes
};

class WoBleTxHistogram
{
public:
    uint8_t     Idx;            // indice to the last TxTime record
    uint8_t     Total;          // total number of records
    WoBleTxRecord   *Record;    // the TxTime records
    FILE *      File;           // the storage
};

/*
 * Declaration of WoBleTest class which is a friend of BleLayer and BLEEndPoint
 * This object contains all the related data and functions for conducting a WoBle throughput test.
 * It also keeps the last test request and result.
 */
class NL_DLL_EXPORT WoBleTest
{
    friend class BleLayer;
    friend class BLEEndPoint;

public:
    // Public data members:
    BTCommandTypeTestRequest    mCommandTestRequest;
    BTCommandTypeTestResult     mCommandTestResult;

    // Public functions:
    void Decode(uint8_t *src, uint8_t *dst, size_t size);
    void DoTxTiming(PacketBuffer *data, int stage);
    BLE_ERROR DoCommandTestRequest(BLEEndPoint *obj);
    BLE_ERROR DoCommandTestResult(int32_t op, int32_t result);
    BLE_ERROR DoCommandTestAbort(int32_t result);
    BLE_ERROR DoCommandTxTiming(bool enable);
    static BLE_ERROR HandleCommandTest(BLEEndPoint *obj);
    static BLE_ERROR HandleCommandTxTiming(BLEEndPoint *obj, bool enabled);
    static void LogBleTestResult(BTCommandTypeTestResult *result);

    // TxTime histogram functions
    int InitTxHistogram(char *file, int count, bool reset); // Initialize Tx histogram table
    void AddTxRecord(uint32_t ts, uint16_t tm, uint16_t size);
    void SaveTxRecords(uint8_t N);      // Save the first N records into file
    void DoneTxHistogram(bool final);   // Clean up the records (& storage)

private:
    // Private data members:
    pthread_t   mMainThread;            // Main thread
    pthread_t   mTestTxThread;          // Tx test thread
    BLEEndPoint *mEp;                   // The associated endpoint
    BleTransportCommandMessage  mCommand;   // buffer for encode/decode
    PacketBuffer *mCommandReceiveQueue; // for received control packets
    PacketBuffer *mCommandSendQueue;    // for sending command data packets
    PacketBuffer *mCommandAckToSend;    // for sending command ack packet
    int mCommandUnderTest;              // UnderTest mode
    bool mCommandTxTiming;              // Flag indicates whether Tx timing is enabled

    WoBleTxHistogram mTxHistogram;      // TxTiming Histogram

    // time statistics
    struct {
        uint32_t mTxStartMs;    // WoBle Tx start time in ms
        uint32_t mTxAckStartMs; // WoBle Tx start time for Test Data Ack
        uint16_t mTxPayload;    // WoBle payload in bytes
    } mTimeStats;               // Up to two outstanding Tx WoBle packets

    // Private functions:
    BLE_ERROR Init(BLEEndPoint *ep);

    static void HandleCommandReceived(BLEEndPoint *obj, PacketBuffer *data);
    static void HandleCommandPacket(Weave::System::Layer *systemLayer, void *appState, Weave::System::Error err);
    static void DoTestDataSend(Weave::System::Layer *systemLayer, void *appState, Weave::System::Error err);
    static void * StartTxThread(void * ep);
    BLE_ERROR DoCommandSendAck(SequenceNumber_t seqNum, int32_t result);
    BLE_ERROR DoCommandRequestTestResult();
    void StopTestTimer(void);
    static void HandleTestClose(Weave::System::Layer *systemLayer, void *appState, Weave::System::Error err);
};

/*
 * Here are the handlers for WoBle test commands
 *      ble-test
 *      ble-test-result
 *      ble-test-abort
 */
BLE_ERROR HandleCommandTest(void *ble, BLE_CONNECTION_OBJECT connObj, uint32_t packetCount, uint32_t duration, uint16_t txGap, uint8_t needAck, uint16_t payloadSize, bool reverse);
BLE_ERROR HandleCommandTestResult(void *ble, BLE_CONNECTION_OBJECT connObj, bool local);
BLE_ERROR HandleCommandTestAbort(void *ble, BLE_CONNECTION_OBJECT connObj);
BLE_ERROR HandleCommandTxTiming(void *ble, BLE_CONNECTION_OBJECT connObj, bool enabled, bool remote);

// Macro to get the gap between two uint8 sequence numbers: N is the newer
#define SeqNumGap(N, O) ((N >= O)? N - O : N + 256 - O)

// The name of WoBle Tx Histogram log file
#ifndef WOBLE_TX_HISTOGRAM_FILE
#ifdef ANDROID
#define WOBLE_TX_HISTOGRAM_FILE    "/data/misc/nldaemon/woble_tx_histogram.log"
#else
#define WOBLE_TX_HISTOGRAM_FILE    "/tmp/woble_tx_histogram.log"
#endif
#endif
#define WOBLE_TX_RECORD_COUNT   10

} /* namespace Ble */
} /* namespace nl */

#endif /* WOBLE_TEST_H_ */