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

#include <ecp/core.h>
#include <ecp/dir/dir.h>
#include <ecp/vconn/vconn.h>

#include <util.h>

#include "init_vconn.h"
#include "vc_common.h"

ECPContext ctx;
ECPSocket sock;
ECPConnHandler handler;
ECPConnHandler dir_handler;
ECPConnHandler vconn_handler;
ECPConnHandler vlink_handler;

#define CTYPE_TEST  0
#define MTYPE_MSG   0

static int handle_open(ECPConnection *conn, ECP2Buffer *b) {
    printf("OPEN\n");

    return ECP_OK;
}

static ssize_t handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) {
    char *_msg = "VAISTINU JE CAR!";
    ssize_t rv;

    printf("MSG:%s size:%ld\n", msg, msg_size);
    rv = ecp_msg_send(conn, MTYPE_MSG, (unsigned char *)_msg, strlen(_msg)+1);

    return msg_size;
}

static ssize_t handle_dir_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) {
    size_t rsize;
    uint16_t count;
    ECPConnection *vlink;
    int rv;

    if (msg_size < sizeof(uint16_t)) return ECP_ERR_SIZE;

    count = \
        ((uint16_t)msg[0] << 8) | \
        ((uint16_t)msg[1]);

    printf("DIR MSG:%d\n", count);

    rsize = sizeof(uint16_t) + count * ECP_SIZE_DIR_ITEM;
    if (msg_size < rsize) return ECP_ERR_SIZE;

    msg += sizeof(uint16_t);

    vlink = malloc(sizeof(ECPConnection));
    if (vlink == NULL) return ECP_ERR_ALLOC;

    ecp_vlink_init(vlink, conn->sock);
    rv = vc_open_inb(vlink, msg, count, &conn->sock->key_perma.public);
    if (rv) {
        free(vlink);
        return rv;
    }

    return rsize;
}

static void usage(char *arg) {
    fprintf(stderr, "Usage: %s <my.priv> <dir pub> <dir addr>\n", arg);
    exit(1);
}

int main(int argc, char *argv[]) {
    ECPConnection *conn_dir;
    ECPNode node_dir;
    ecp_ecdh_public_t dir_pub;
    ECPDHKey key_perma;
    int rv;

    if (argc != 4) usage(argv[0]);

    rv = ecp_init(&ctx, &vconn_handler, &vlink_handler);
    printf("ecp_init RV:%d\n", rv);

    ecp_conn_handler_init(&dir_handler, handle_dir_msg, ecp_dir_handle_open, NULL, NULL);
    ecp_ctx_set_handler(&ctx, ECP_CTYPE_DIR, &dir_handler);

    ecp_conn_handler_init(&handler, handle_msg, handle_open, NULL, NULL);
    ecp_ctx_set_handler(&ctx, CTYPE_TEST, &handler);

    rv = ecp_util_load_key(&key_perma.public, &key_perma.private, argv[1]);
    printf("ecp_util_load_key RV:%d\n", rv);
    key_perma.valid = 1;

    rv = ecp_sock_create(&sock, &ctx, &key_perma);
    printf("ecp_sock_create RV:%d\n", rv);

    rv = ecp_sock_open(&sock, NULL);
    printf("ecp_sock_open RV:%d\n", rv);

    rv = ecp_start_receiver(&sock);
    printf("ecp_start_receiver RV:%d\n", rv);

    rv = ecp_util_load_pub(&dir_pub, argv[2]);
    printf("ecp_util_load_pub RV:%d\n", rv);

    ecp_node_init(&node_dir, &dir_pub, NULL);
    rv = ecp_node_set_addr(&node_dir, argv[3]);
    printf("ecp_node_set_addr RV:%d\n", rv);

    conn_dir = malloc(sizeof(ECPConnection));
    if (conn_dir == NULL) printf("out of memory\n");

    ecp_dir_conn_init(conn_dir, &sock);
    rv = ecp_conn_open(conn_dir, &node_dir);
    printf("ecp_conn_open RV:%d\n", rv);

    while (1) sleep(1);
}