//
// Created by YY on 2019/12/27.
//

#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <pthread.h>
#include <semaphore.h>
#include "platform.h"
#include "../jni_log.h"
#include "../common/net.h"
#include "../native-lib.h"
#include "../common/apptimer.h"
#include "parse_net.h"
#include "../defs.h"
#include "../rtk_module/rtk.h"

#define PARSE_BUFF_SIZE         4096

const char *VK_REG = "platform_register";

struct platformSocket {
    char domain_name[32];
    int port;
};

static struct deviceInfo_ {
    uint16_t province;
    uint16_t city;
    uint8_t device_model[21];
    uint8_t device_sn[17];
    char imei[16];
}deviceInfo;

struct platformSocketInfo {
    char domain_name[32];
    int port;
};

static struct platformStatus_ {
    uint8_t platformKey[64];
    int platformKeyLength;
    uint32_t connected : 1;
    uint32_t registed : 1;
    uint32_t login : 1;
    uint32_t downloadRtk : 1;
} platformStatus;

struct platformSocket exceptSocket, currSocket;
static uint32_t eventMask;
static sem_t sem_status_changed;

static bool requestPlatformSendRtk = false;
static int platform_tcp_fd = 0;

static pthread_mutex_t platform_tx_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t events_mutex = PTHREAD_MUTEX_INITIALIZER;

static void ConnectPlatform(const char *domain_name, int port);
static void ConnectPlatformLater(union sigval sig);

static void *PlatformDataListenThread(void *p);
static void *StatusListenThread(void *p);

static void RegisterPlatform(void);
static void RegisterPlatformTimeout(union sigval sig);

static void LoginPlatform(void);
static void LoginPlatformTimeout(union sigval sig);
static void TriggerHeartbeat(union sigval sig);

void InitPlatform(const uint8_t *phone, const char *domain_name, int port)
{
    pthread_mutex_init(&platform_tx_mutex, NULL);
    pthread_mutex_init(&events_mutex, NULL);

    eventMask = 0;
    platform_tcp_fd = -1;
    memset(&currSocket, 0, sizeof(currSocket));
    strcpy(exceptSocket.domain_name, domain_name);
    exceptSocket.port = port;

    sem_init(&sem_status_changed, 0, 0);

    strcpy(deviceInfo.imei, GetImei());
    deviceInfo.province = 53;
    deviceInfo.city = 100;
    strcpy((char *)deviceInfo.device_model, "RTKBaseStation");
    strcpy((char *)deviceInfo.device_sn, "2019101500000001");

    PlatformTxInit(phone);

    pthread_t pid;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);//detached
    pthread_create(&pid, &attr, StatusListenThread, NULL);

    strcpy(deviceInfo.imei, GetImei());

    ConnectPlatform(domain_name, port);
}

void PlatformStatusChanged(uint32_t event)
{
    pthread_mutex_lock(&events_mutex);
    eventMask |= event;
    pthread_mutex_unlock(&events_mutex);
    sem_post(&sem_status_changed);
}

static void ConnectPlatform(const char *domain_name, int port)
{
    DEBUG("ConnectPlatform %s: %d", domain_name, port);
    // TODO
    struct platformSocketInfo *ptr = (struct platformSocketInfo *)malloc(sizeof(struct platformSocketInfo));

    strcpy(ptr->domain_name, domain_name);
    ptr->port = port;

    pthread_t platform_pid;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);//detached
    pthread_create(&platform_pid, &attr, PlatformDataListenThread, ptr);

    char out[64];
    sprintf(out, "连接平台 %s:%d...", domain_name, port);
    DisplayText(out);
}

static void ConnectPlatformLater(union sigval sig) {
    AppTimer_delete(ConnectPlatformLater);
    ConnectPlatform(exceptSocket.domain_name, exceptSocket.port);
}

static void *StatusListenThread(void *p) {
    while (true) {
        sem_wait(&sem_status_changed);

        uint32_t events;
        pthread_mutex_lock(&events_mutex);
        events = eventMask;
        eventMask = 0;
        pthread_mutex_unlock(&events_mutex);

        if (events & PLATFORM_CONNECT_EVT) {
            char out[64];
            sprintf(out, "平台连接成功 %s:%d", currSocket.domain_name, currSocket.port);
            DisplayText(out);

            platformStatus.connected = 1;
            if (!platformStatus.registed || platformStatus.platformKeyLength == 0) {
                RegisterPlatform();
            } else if (!platformStatus.login) {
                LoginPlatform();
            }
        }

        if (events & PLATFORM_DISCONNECT_EVT) {
            char out[64];
            sprintf(out, "平台断开 %s:%d", currSocket.domain_name, currSocket.port);
            DisplayText(out);

            AppTimer_delete(ConnectPlatformLater);
            AppTimer_add(ConnectPlatformLater, D_SEC(2));

            platformStatus.login = 0;
            platformStatus.connected = 0;

            AppTimer_delete(TriggerHeartbeat);
            AppTimer_delete(RegisterPlatformTimeout);
            AppTimer_delete(LoginPlatformTimeout);
        }
        if (events & PLATFORM_REGISTER_EVT) {
            DEBUG("PLATFORM_REGISTER_EVT");
            platformStatus.platformKeyLength = GetPlatformKey(platformStatus.platformKey);
            platformStatus.registed = GetSharedValue(VK_REG);
            platformStatus.login = 0;
            DEBUG("platformStatus.platformKeyLength = %d", platformStatus.platformKeyLength);

            if (platformStatus.registed && platformStatus.platformKeyLength > 0) {
                LoginPlatform();
            }
        }
        if (events & PLATFORM_LOGIN_EVT) {
            DEBUG("PLATFORM_LOGIN_EVT");
            platformStatus.login = 1;
            requestPlatformSendRtk = true;
            AppTimer_delete(TriggerHeartbeat);
            AppTimer_add(TriggerHeartbeat, D_SEC(30));
        }
    }
}

static void *PlatformDataListenThread(void *p) {
    struct platformSocket *ptr = (struct platformSocket *)p;

    uint8_t RxBuf[PARSE_BUFF_SIZE];

    int fds_ret;
    struct timeval tv;
    fd_set rdfds;
    fd_set exfds;

    int fd = -1;
    int RxBufLen = 0;

    fd = ConnectTCP(ptr->domain_name, ptr->port);

    pthread_mutex_lock(&platform_tx_mutex);
    platform_tcp_fd = fd;

    currSocket = *ptr;

    pthread_mutex_unlock(&platform_tx_mutex);

    if (fd > 0) {
        PlatformStatusChanged(PLATFORM_CONNECT_EVT);
    }

    while (fd > 0) {
        tv.tv_sec = 5;
        tv.tv_usec = 0;
        FD_ZERO(&rdfds); //clean
        FD_SET(fd, &rdfds); //set

        fds_ret = select(fd + 1, &rdfds, NULL, NULL, &tv);

        if (fds_ret < 0) {
            break;
        } else if(fds_ret == 0) {
            //Occur failure(such as line disconnect)
        } else if(FD_ISSET(fd, &rdfds)) {
            RxBufLen = ReadTCP(fd, RxBuf, sizeof(RxBuf));

            if (RxBufLen < 0) {
                break;
            } else if (RxBufLen > 0) {
                Parse(DATA_ACCESS_PLATFORM, RxBuf, RxBufLen);
            }
        }
    }

    pthread_mutex_lock(&platform_tx_mutex);
    if (platform_tcp_fd > 0) {
        DisconnectTCP(platform_tcp_fd);
        platform_tcp_fd = -1;
    }
    pthread_mutex_unlock(&platform_tx_mutex);
    free(ptr);

    PlatformStatusChanged(PLATFORM_DISCONNECT_EVT);
    pthread_exit(NULL);
}

int WritePlatform(const uint8_t * buf, uint32_t len)
{
    int ret = -1;

    pthread_mutex_lock(&platform_tx_mutex);
    if (platform_tcp_fd > 0) {
        ret = WriteTCP(platform_tcp_fd, buf, len);
    }
    pthread_mutex_unlock(&platform_tx_mutex);

    return ret;
}

static void RegisterPlatformTimeout(union sigval sig)
{
    DEBUG("RegisterPlatformTimeout");
    AppTimer_delete(RegisterPlatformTimeout);
    RegisterPlatform();
}

static void RegisterPlatform(void)
{
    AppTimer_delete(RegisterPlatformTimeout);
    AppTimer_add(RegisterPlatformTimeout, D_SEC(15));
    SendDeviceRegister(deviceInfo.province, deviceInfo.city, deviceInfo.device_model,
                       strlen((char *)deviceInfo.device_model), deviceInfo.device_sn, deviceInfo.imei);
}

static void TriggerHeartbeat(union sigval sig) {
    AppTimer_delete(TriggerHeartbeat);

    if (platformStatus.login && platformStatus.connected) {
        SendHeartBeat(DATA_ACCESS_PLATFORM);
        AppTimer_add(TriggerHeartbeat, D_SEC(30));
    }
}

static void LoginPlatformTimeout(union sigval sig)
{
    AppTimer_delete(LoginPlatformTimeout);
    LoginPlatform();
}

static void LoginPlatform(void)
{
    uint32_t tim = time(NULL);
    uint8_t data[12];
    uint8_t *ciphertext;

    data[0] = BREAK_UINT32(tim, 3);
    data[1] = BREAK_UINT32(tim, 2);
    data[2] = BREAK_UINT32(tim, 1);
    data[3] = BREAK_UINT32(tim, 0);

    AppTimer_delete(LoginPlatformTimeout);
    AppTimer_add(LoginPlatformTimeout, D_SEC(15));

    DESEncrypt(platformStatus.platformKey, platformStatus.platformKeyLength, data, 4, &ciphertext);

    if (ciphertext != NULL) {
        memcpy(data + 4, ciphertext, 8);
        SendDeviceLogin(data, sizeof(data));
    }
}

void DeviceRegisterCallback(uint8_t res, const uint8_t *data, int length)
{
    AppTimer_delete(RegisterPlatformTimeout);
    if (res != 0) {

    } else {
        TextSpeak("终端注册成功");
        DisplayText("终端注册成功");
        SetPlatformKey(data, length);
        SetSharedValue(VK_REG, 1);
        PlatformStatusChanged(PLATFORM_REGISTER_EVT);
    }
}

void DeviceLoginCallback(uint8_t res)
{
    AppTimer_delete(LoginPlatformTimeout);
    if (res != 0) {

    } else {
        TextSpeak("终端登录成功");
        DisplayText("终端登录成功");
        PlatformStatusChanged(PLATFORM_LOGIN_EVT);
    }
}

void RequestRtkDownload(uint32_t latitude, uint32_t longitude, uint16_t altitude,
                        const uint8_t *bcd_time, uint16_t rtk_pkt_interval)
{
    if (requestPlatformSendRtk) {
        requestPlatformSendRtk = false;
        SendRTKStart(latitude, longitude, altitude, bcd_time, rtk_pkt_interval);
    }
}

void StopRtkDownload(void)
{
    SendRTKStop();
}