//
// Created by YY on 2019/9/29.
//

#include <netdb.h>
#include <cstring>
#include <netinet/tcp.h>
#include <unistd.h>
#include <netinet/in.h>
#include <cstdio>
#include <cerrno>
#include <sys/select.h>
#include <arpa/inet.h>
#include <regex>
#include <pthread.h>
#include <semaphore.h>
#include <string>

#include "net.h"
#include "../jni_log.h"

#define DEBUG(fmt, args...)     LOGD("<net> <%s>: " fmt, __func__, ##args)
#define PARSE_BUFF_SIZE     4096

using namespace std;

CTcpPort::CTcpPort()
{
    m_iServiceType = TYPE_CLIENT;
    m_sIp.clear();
    m_nPort = 0;
    m_connected = false;
    m_pClientSocket = 0;
    m_pServerSocket = 0;

    event_func = NULL;
    event_func_context = NULL;
    receive_data_func = NULL;
    receive_data_func_context = NULL;
}

CTcpPort::~CTcpPort()
{
    CloseTcpPort();
}

bool CTcpPort::IsOpen(void)
{
    if (m_iServiceType == TYPE_SERVER) {
        if (m_pServerSocket > 0) {
            return true;
        } else {
            return false;
        }
    } else {
        if (m_pClientSocket > 0) {
            return true;
        } else {
            return false;
        }
    }
}

bool CTcpPort::OpenTcpPort(const char *ip, int port)
{
    if (IsOpen()) {
        return true;
    }

    m_sIp = ip;
    m_nPort = 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, TcpConnectThread, this);

    return true;
}

/*************************************************************
	host_name:domain name
	net_addr:return numbers-and-dots notation
*/
int CTcpPort::GetHostIP(const char *host_name, char *net_addr)
{
    struct hostent *hptr;
    char **pptr;
    char str[32];
    bool found_first = false;

    if ((hptr = gethostbyname(host_name)) == NULL) {
        DEBUG("gethostbyname error\n");
        return -1;
    }

    DEBUG("official hostname: %s\n", hptr->h_name);

    for (pptr = hptr->h_aliases; *pptr != NULL; pptr++) {
        DEBUG("alias:%s\n", *pptr);
    }

    switch(hptr->h_addrtype)
    {
        case AF_INET:
        {
            for (pptr = hptr->h_addr_list; *pptr != NULL; pptr++) {
                DEBUG("addrsss:%s\n", inet_ntop(hptr->h_addrtype, *pptr, str, sizeof(str)));
                if (!found_first) {
                    strcpy(net_addr, str);
                    found_first = true;
                }
            }
            break;
        }
        case AF_INET6:
        default:
            DEBUG("unknown address type\n");
            break;
    }

    if (found_first == true) {
        return 0;
    }
    return -2;
}

bool CTcpPort::is_domain_name(const char *ip)
{
    regex pattern0("^((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})(\\.((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})){3}$");
    string target(ip);

    return !regex_match(target, pattern0);
}

int CTcpPort::socket_set_keepalive(int fd)
{
    int alive, idle, cnt, intv;

//    int value, value_len;
//    getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &value_len);
//    DEBUG("keepalive 0 %d", value);

//    value = 128;
//    setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value));
//    DEBUG("keepalive 1 %d", value);

//    getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &value_len);
//    DEBUG("keepalive 1 %d", value);


    /* Set: use keepalive on fd, default 0 */
    alive = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &alive, sizeof(alive)) != 0)
    {
        DEBUG("TCP Set keepalive error");
        return -1;
    }
    /* 20 Seconds not data, send keeplive packet, default 7200 */
    idle = 20;
    if (setsockopt (fd, SOL_TCP, TCP_KEEPIDLE, &idle, sizeof(idle)) != 0)
    {
        DEBUG("TCP Set keepalive idle error");
        return -1;
    }
    /* If not recv respond, After 5 seconds retry, default 75 */
    intv = 5;
    if (setsockopt (fd, SOL_TCP, TCP_KEEPINTVL, &intv, sizeof(intv)) != 0)
    {
        DEBUG("TCP Set keepalive intv error");
        return -1;
    }
    /* If try 9 times and fail, we consider the tcp is disconnected, default 9 */
    cnt = 9;
    if (setsockopt (fd, SOL_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt)) != 0)
    {
        DEBUG("TCP Set keepalive cnt error");
        return -1;
    }

/*    int timeout = 10000;        // 10秒
    if (setsockopt (fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout, sizeof(timeout)) != 0)
    {
        DEBUG("TCP Set keepalive timeout error");
        return -1;
    }*/

    DEBUG("TCP Set keepalive OK");

    return 0;
}

int CTcpPort::tcp_connect(char *ip, uint16_t port)
{
    struct sockaddr_in server_sockaddr;
    int soc;
    int ret, fds_ret;
    struct timeval tv;
    fd_set rdfds;
    long arg;
    int error_value;
    socklen_t error_value_len;

    DEBUG("tcp_connect... %s : %d", ip, port);

    error_value_len = sizeof( error_value );

    if((soc = socket(PF_INET, SOCK_STREAM, 0)) == -1)
    {
        DEBUG("%s: socket", __func__);
        return -1;
    }

    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_addr.s_addr = inet_addr(ip);//htonl(ip);//inet_addr("192.168.1.37");
    server_sockaddr.sin_port = htons(port);
    bzero(&server_sockaddr.sin_zero, 8);

    // Set non-blocking
    if( (arg = fcntl(soc, F_GETFL, NULL)) < 0)
    {
        DEBUG("%s: fcntl( F_GETFL ) error", __func__);
        goto TCP_CONNECT_1;
    }

    if( fcntl(soc, F_SETFL, arg | O_NONBLOCK) < 0)
    {
        DEBUG( "%s: fcntl( F_SETFL ) error", __func__);
        goto TCP_CONNECT_1;
    }

    ret = connect(soc, (struct sockaddr*)&server_sockaddr, sizeof(struct sockaddr));

    if(ret < 0)
    {
        if(errno != EINPROGRESS)		//It usually return this error!
        {
            /*
             * connect error: Connection refused
             *
             * perror( "connect error" );
             */
            goto TCP_CONNECT_1;
        }
    }
    else if(ret == 0)
    {
        goto TCP_CONNECT_0;
    }

    tv.tv_sec = 10;		//Connect Timeout
    tv.tv_usec = 0;
    FD_ZERO(&rdfds);
    FD_SET(soc, &rdfds);

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

    if(fds_ret < 0)
    {
        DEBUG( "%s: TCP select error", __func__);
        goto TCP_CONNECT_1;
    }
    else if(fds_ret == 0)
    {
        DEBUG("%s: TCP Connect Timeout %ld", __func__, tv.tv_sec);
        goto TCP_CONNECT_1;
    }
    else if(FD_ISSET(soc, &rdfds))
    {
        if(getsockopt(soc, SOL_SOCKET, SO_ERROR, &error_value, &error_value_len) < 0)
        {
            goto TCP_CONNECT_1;
        }
    }
    else
    {
        DEBUG("%s: some error occur in tcp_connect()", __func__);
        goto TCP_CONNECT_1;
    }

    TCP_CONNECT_0:
//    if ( fcntl( soc, F_SETFL, arg ) < 0 )
//    {
//        perror( "fcntl( F_SETFL ) error" );
//        goto TCP_CONNECT_1;
//    }

    if ( error_value != 0 )
    {
        /*
         * Error: Connection refused
         *
         * fprintf( stderr, "Error: %s", strerror( error_value ) );
         */
        goto TCP_CONNECT_1;
    }

    if(socket_set_keepalive(soc) != 0)
    {
        goto TCP_CONNECT_1;
    }

    arg &= ~O_NONBLOCK;
    if( fcntl(soc, F_SETFL, arg) < 0)
    {
        DEBUG( "%s: fcntl( F_SETFL ) error", __func__);
        goto TCP_CONNECT_1;
    }

    DEBUG("%s: tcp connected %s: %d", __func__, ip, port);

    return( soc );

    TCP_CONNECT_1:
    close( soc );
    return( -1 );
}

void *CTcpPort::TcpConnectThread(void *p)
{
    CTcpPort *pCTcpPort = (CTcpPort *)p;

    char net_addr[32] = {0};

    if (pCTcpPort->is_domain_name(pCTcpPort->m_sIp.c_str())) {
        if (pCTcpPort->GetHostIP(pCTcpPort->m_sIp.c_str(), net_addr) != 0) {
            goto CONNECT_END;
        }
    } else {
        strcpy(net_addr, pCTcpPort->m_sIp.c_str());
    }

    pCTcpPort->m_pClientSocket = pCTcpPort->tcp_connect(net_addr, pCTcpPort->m_nPort);

    if (pCTcpPort->m_pClientSocket > 0) {
        if (pCTcpPort->event_func != NULL) {
            pCTcpPort->event_func(0, pCTcpPort, pCTcpPort->event_func_context);
        }

        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, TcpListenThread, p);
    } else {
        if (pCTcpPort->event_func != NULL) {
            pCTcpPort->event_func(-1, pCTcpPort, pCTcpPort->event_func_context);
        }
    }

CONNECT_END:
    pthread_exit(NULL);
}

void *CTcpPort::TcpListenThread(void *p)
{
    int fds_ret;
    struct timeval tv;
    fd_set rdfds;
    fd_set exfds;
    uint8_t RxBuf[PARSE_BUFF_SIZE];

    CTcpPort *pCTcpPort = (CTcpPort *)p;

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

        fds_ret = select(pCTcpPort->m_pClientSocket + 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(pCTcpPort->m_pClientSocket, &rdfds)) {
            int recvLen = recv(pCTcpPort->m_pClientSocket, RxBuf, sizeof(RxBuf), 0);

            if (recvLen == 0) {
                LOGW("tcp error TCP disconnected 0 errno = %d", errno);
                break;
            } else if (recvLen < 0) {
                if (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN) {

                } else {
                    LOGW("tcp error TCP disconnected errno = %d", errno);;
                    break;
                }
            }

            if (recvLen > 0) {
                if (pCTcpPort->receive_data_func != NULL) {
                    pCTcpPort->receive_data_func(RxBuf, recvLen, pCTcpPort, pCTcpPort->receive_data_func_context);
                }
            }
        }
    }

    pCTcpPort->CloseTcpPort();

    if (pCTcpPort->event_func) {
        pCTcpPort->event_func(-1, pCTcpPort, pCTcpPort->event_func_context);
    }

    pthread_exit(NULL);
}

void CTcpPort::set_event_callback(void (*callback)(int, void *, void *), void *context)
{
    event_func = callback;
    event_func_context = context;
}

void CTcpPort::set_data_callback(void (*callback)(void *, int, void *, void *), void *context)
{
    receive_data_func = callback;
    receive_data_func_context = context;
}

int CTcpPort::WriteTCP(const uint8_t * buf, uint32_t len)
{
    int ret = 0;
    int fds_ret;
    struct timeval tv;
    fd_set rdfds;

    if (m_pClientSocket <= 0)
        return -2;

    /*******************************************************
    TCP send with nonblock, if occur failure(such as line disconnect...),
    will send timeout, so terminate TCP.
    */
    tv.tv_sec = 5;
    tv.tv_usec = 0;

    FD_ZERO(&rdfds); //clean
    FD_SET(m_pClientSocket, &rdfds); //set

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

    if (fds_ret < 0) {
        DEBUG("tcp error send select error");
        return -1;
    } else if(fds_ret == 0) {
        DEBUG("tcp error Occur failure(such as line disconnect)");
        //Occur failure(such as line disconnect)
        ret = -1;
    } else if(FD_ISSET(m_pClientSocket, &rdfds)) {
        ret = send(m_pClientSocket, buf, len, 0);
        if(ret == -1) {
            DEBUG("tcp error TCP Send Error");
        }
    } else {
        DEBUG("tcp error tcp send has error\n");
    }

    return ret;
}

bool CTcpPort::CloseTcpPort(void)
{
    DEBUG("DisconnectTCP fd = %d", m_pClientSocket);

    if (m_pClientSocket > 0) {
        shutdown(m_pClientSocket, SHUT_RDWR);
        close(m_pClientSocket);
        m_pClientSocket = 0;
        return true;
    }
    return false;
}