//
// Created by ps on 18-11-27.
//

#include <stdio.h>
#include <sys/types.h>
#include <cstring>
#include <arpa/inet.h>
#include <iostream>
#include <zconf.h>
#include <thread>

#ifdef _WIN32
#   define __WIN32__
#   include <WinSock2.h>
#   pragma comment(lib, "ws2_32.lib")
#   pragma comment(lib, "ei_md.lib")
#   pragma comment(lib, "erl_interface_md.lib")
#   pragma comment(linker, "/NODEFAULTLIB:MSVCRTD.LIB")
#endif

#include "erl_interface.h"
#include "ei.h"

#define BUFSIZE 1000
#define PORT 13001

int foo(int x) {
    return x + 1;
}

int bar(int y) {
    return y * 2;
}

int my_listen(int port);

int main(int argc, char **argv) {
    struct in_addr addr;                     /* 32-bit IP number of host */
    int port;                                /* Listen port number */
    int listen;                              /* Listen socket */
    int fd;                                  /* fd to Erlang node */
    ErlConnect conn;                         /* Connection data */

    int loop = 1;                            /* Loop flag */
    int got;                                 /* Result of receive */
    unsigned char buf[BUFSIZE];              /* Buffer for incoming message */
    ErlMessage emsg;                         /* Incoming message */

    ETERM *fromp, *tuplep, *fnp, *argp, *resp;
    int res;

#ifdef _WIN32
    //初始化winsock服务
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2,2), &wsaData);
#endif

    port = PORT;

    erl_init(NULL, 0);

    addr.s_addr = inet_addr("127.0.0.1");
    if (erl_connect_xinit("test", "c1", "c1@127.0.0.1",
                          &addr, "1234", 0) == -1)
        erl_err_quit("erl_connect_xinit");

    if (erl_connect_xinit("test2", "c2", "c2@127.0.0.1",
                          &addr, "1234", 0) == -1)
        erl_err_quit("erl_connect_xinit2");

    std::thread th1([&] {

        /* Make a listen socket */
        if ((listen = my_listen(port)) <= 0)
            erl_err_quit("my_listen");

        if (erl_publish(port) == -1)
            erl_err_quit("erl_publish");

        if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
            erl_err_quit("erl_accept");
        fprintf(stderr, "Connected to %s,,,%d\n\r", conn.nodename, fd);

        while (loop) {
//        std::cout << "hello world" << std::endl;
            got = erl_receive_msg(fd, buf, BUFSIZE, &emsg);
            if (got == ERL_TICK) {
                /* ignore */
            } else if (got == ERL_ERROR) {
                if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
                    erl_err_quit("erl_accept");
                fprintf(stderr, "Connected to %s,,,%d\n\r", conn.nodename, fd);
            } else {

                if (emsg.type == ERL_REG_SEND) {
                    fromp = erl_element(2, emsg.msg);
                    tuplep = erl_element(3, emsg.msg);
                    fnp = erl_element(1, tuplep);
                    argp = erl_element(2, tuplep);

                    if (strncmp(ERL_ATOM_PTR(fnp), "foo", 3) == 0) {
                        res = foo(ERL_INT_VALUE(argp));
                        std::cout << "foo is  " << res << std::endl;
                    } else if (strncmp(ERL_ATOM_PTR(fnp), "bar", 3) == 0) {
                        res = bar(ERL_INT_VALUE(argp));
                        std::cout << "bar is  " << res << std::endl;
                    }

                    std::cout << "message is  " << ERL_ATOM_PTR(fnp) << std::endl;

                    resp = erl_format("{c1, {res,~i}}", res);
                    erl_send(fd, fromp, resp);

                    erl_free_term(emsg.from);
                    erl_free_term(emsg.msg);
                    erl_free_term(fromp);
                    erl_free_term(tuplep);
                    erl_free_term(fnp);
                    erl_free_term(argp);
                    erl_free_term(resp);
                }
            }

        }
    });

//    std::thread th2([&] {
//
//        /* Make a listen socket */
//        if ((listen = my_listen(8011)) <= 0)
//            erl_err_quit("my_listen 2");
//
//        if (erl_publish(8011) == -1)
//            erl_err_quit("erl_publish 2");
//
//        if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
//            erl_err_quit("erl_accept 2");
//        fprintf(stderr, "Connected to %s\n\r", conn.nodename);
//
//        while (loop) {
////        std::cout << "hello world" << std::endl;
//            got = erl_receive_msg(fd, buf, BUFSIZE, &emsg);
//            if (got == ERL_TICK) {
//                /* ignore */
//            } else if (got == ERL_ERROR) {
//                usleep(100);
////            loop = 0;
//            } else {
//
//                if (emsg.type == ERL_REG_SEND) {
//                    fromp = erl_element(2, emsg.msg);
//                    tuplep = erl_element(3, emsg.msg);
//                    fnp = erl_element(1, tuplep);
//                    argp = erl_element(2, tuplep);
//
//                    if (strncmp(ERL_ATOM_PTR(fnp), "foo", 3) == 0) {
//                        res = foo(ERL_INT_VALUE(argp));
//                        std::cout << "foo is  " << res << std::endl;
//                    } else if (strncmp(ERL_ATOM_PTR(fnp), "bar", 3) == 0) {
//                        res = bar(ERL_INT_VALUE(argp));
//                        std::cout << "bar is  " << res << std::endl;
//                    }
//
//                    std::cout << "message is  " << ERL_ATOM_PTR(fnp) << std::endl;
//
//                    resp = erl_format("{c1, {res,~i}}", res);
//                    erl_send(fd, fromp, resp);
//
//                    erl_free_term(emsg.from);
//                    erl_free_term(emsg.msg);
//                    erl_free_term(fromp);
//                    erl_free_term(tuplep);
//                    erl_free_term(fnp);
//                    erl_free_term(argp);
//                    erl_free_term(resp);
//                }
//            }
//
//        }
//    });

    th1.detach();
//    th2.detach();

    getchar();
}


int my_listen(int port) {
    int listen_fd;
    struct sockaddr_in addr;
    int on = 1;

    if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        return (-1);

    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

    memset((void *) &addr, 0, (size_t) sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(listen_fd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
        return (-1);

    listen(listen_fd, 5);
    return listen_fd;
}