#include <stdlib.h>
#include <string.h>

#include <ecp/core.h>
#include <ecp/tr.h>

#include <eos/eos.h>
#include <eos/dev/net.h>

ECPSocket *_ecp_tr_sock = NULL;
unsigned char pld_buf[ECP_MAX_PLD];

static void packet_handler(unsigned char type, unsigned char *buffer, uint16_t buf_len) {
    ECP2Buffer bufs;
    ECPBuffer packet;
    ECPBuffer payload;
    ecp_tr_addr_t addr;
    size_t hdr_size;
    ssize_t rv;
    unsigned char *_packet;
    int _rv;

    _rv = eos_sock_recvfrom(buffer, buf_len, &addr, NULL, 0);
    if (!_rv) _packet = eos_sock_buf2pkt(buffer, buf_len);
    if (_rv || _packet == NULL) {
        if (_rv == EOS_SOCK_ERR_CLOSED) _ecp_tr_sock->sock = 0;
        eos_net_free(buffer, 0);
        return;
    }

    bufs.packet = &packet;
    bufs.payload = &payload;

    hdr_size = _packet - buffer;
    packet.buffer = _packet;
    packet.size = EOS_NET_MTU - hdr_size;
    payload.buffer = pld_buf;
    payload.size = ECP_MAX_PLD;

    rv = ecp_pkt_handle(_ecp_tr_sock, NULL, &addr, &bufs, buf_len - hdr_size);
    if (rv < 0) ECP_LOG_ERR(_ecp_tr_sock, "packet_handler: err:%d\n", (int)rv);

    if (bufs.packet->buffer) {
        eos_net_free(buffer, 0);
    } else {
        eos_net_release();
    }
}

int ecp_tr_init(ECPContext *ctx) {
    return ECP_OK;
}

unsigned int ecp_tr_addr_hash(ecp_tr_addr_t *addr) {
    unsigned int ret = *((unsigned int *)addr->host);
    return ret ^ ((unsigned int)addr->port << 16);
}

int ecp_tr_addr_eq(ecp_tr_addr_t *addr1, ecp_tr_addr_t *addr2) {
    if (addr1->port != addr2->port) return 0;
    if (memcmp(addr1->host, addr2->host, sizeof(addr1->host)) != 0) return 0;
    return 1;
}

int ecp_tr_addr_set(ecp_tr_addr_t *addr, void *addr_s) {
    return ECP_ERR;
}

int ecp_tr_open(ECPSocket *sock, ecp_tr_addr_t *addr) {
    int rv;

    rv = eos_sock_open_udp(packet_handler, NULL);
    if (rv < 0) return ECP_ERR_OPEN;

    sock->sock = rv;
    _ecp_tr_sock = sock;

    return ECP_OK;
}

void ecp_tr_close(ECPSocket *sock) {
    eos_sock_close(sock->sock, NULL);
    _ecp_tr_sock = NULL;
}

ssize_t ecp_tr_send(ECPSocket *sock, ECPBuffer *packet, size_t pkt_size, ecp_tr_addr_t *addr, unsigned char flags) {
    unsigned char *buffer = NULL;
    int reply;
    int rv;

    if (sock->sock == 0) return ECP_ERR_CLOSED;

    reply = 0;
    if (flags & ECP_SEND_FLAG_REPLY) {
        if (flags & ECP_SEND_FLAG_MORE) return ECP_ERR;
        if (packet->buffer == NULL) return ECP_ERR;
        buffer = packet->buffer;
        packet->buffer = NULL;
        reply = 1;
    } else {
        rv = eos_sock_pkt_alloc(&buffer, packet->buffer, pkt_size);
        if (rv) return ECP_ERR;
    }

    rv = eos_sock_sendto_async(sock->sock, addr, buffer, pkt_size, !!(flags & ECP_SEND_FLAG_MORE));
    if (rv) return ECP_ERR_SEND;

    return pkt_size;
}

ssize_t ecp_tr_recv(ECPSocket *sock, ECPBuffer *packet, ecp_tr_addr_t *addr, int timeout) {
    return ECP_ERR;
}

void ecp_tr_release(ECPBuffer *packet, unsigned char more) {
    if (packet->buffer) {
        eos_net_free(eos_sock_pkt2buf(packet->buffer), more);
        packet->buffer = NULL;
    } else if (!more) {
        eos_net_release();
    }
}