void *socket_http_listener()
{
	prctl(PR_SET_NAME, (char *)"HTTP", 0, 0, 0);

	while (1){
		struct client_ctx *cc = socket_listen(&srv_http);
		if (!cc)
			continue;
		struct lnode *n = calloc(sizeof(*n), 1);

		queue_push(n, cc);
	}

	pthread_exit(0);
}

/*-------------------------------------------------------------------------*\
* Puts the sockt in listen mode
\*-------------------------------------------------------------------------*/
static int meth_listen(lua_State *L)
{
    p_tcp tcp = (p_tcp) auxiliar_checkclass(L, "tcp{master}", 1);
    int backlog = (int) luaL_optnumber(L, 2, 32);
    int err = socket_listen(&tcp->sock, backlog);
    if (err != IO_DONE) {
        lua_pushnil(L);
        lua_pushstring(L, socket_strerror(err));
        return 2;
    }
    /* turn master object into a server object */
    auxiliar_setclass(L, "tcp{server}", 1);
    lua_pushnumber(L, 1);
    return 1;
}

int main(){

    lib_init();

    socket_t * serverSocket = socket_new();
    socket_bind(serverSocket, 5000);
    socket_listen(serverSocket);

    film_maker_t*  film_makers[FILM_MAKERS_AMOUNT];

     for (int i = 0; i < FILM_MAKERS_AMOUNT; i++) {
        film_makers[i] = film_maker_new();

    }

       parse(film_makers,"XML_format.xml");


    while(1) {
        socket_t * clientSocket = socket_accept(serverSocket);
        char buf[102400];

        if(socket_read(clientSocket, buf, 102400) == 0) {
            socket_close(clientSocket);
            socket_free(clientSocket);
            puts("Skipping empty request");
            continue;
        }



        http_request_t req = http_request_parse(buf);

        server_reply(clientSocket, req, film_makers);
//puts("fghj");

        socket_close(clientSocket);
        socket_free(clientSocket);
    }

    for (int i = 0; i < 3; i++)
        film_maker_free(film_makers[i]);

    socket_close(serverSocket);
    socket_free(serverSocket);
          lib_free();
        return 0;
}

static void ot_try_bind( char ip[4], uint16 port, int is_tcp ) {
  int64 s = is_tcp ? socket_tcp4( ) : socket_udp4();

  if( socket_bind4_reuse( s, ip, port ) == -1 )
    panic( "socket_bind4_reuse" );

  if( is_tcp && ( socket_listen( s, SOMAXCONN) == -1 ) )
    panic( "socket_listen" );

  if( !io_fd( s ) )
    panic( "io_fd" );

  io_setcookie( s, is_tcp ? FLAG_TCP : FLAG_UDP );

  io_wantread( s );
}

static int64_t ot_try_bind( ot_ip6 ip, uint16_t port ) {
  int64 sock = socket_tcp6( );

  if( socket_bind6_reuse( sock, ip, port, 0 ) == -1 )
    panic( "socket_bind6_reuse" );

  if( socket_listen( sock, SOMAXCONN) == -1 )
    panic( "socket_listen" );

  if( !io_fd( sock ) )
    panic( "io_fd" );

  io_setcookie( sock, (void*)FLAG_SERVERSOCKET );
  io_wantread( sock );
  return sock;
}

/**
 * @brief sctp_server_create 
 *
 * @param sck  [in] socket impl
 * @param ip   [in] listen ip
 * @param port [in] listen port
 *
 * @return 0, if succ; -1, if failed
 */
int sctp_server_create(struct socket_impl *sck, const char *ip, unsigned short port)
{
    struct sctp_initmsg initmsg = {0};
    struct sctp_event_subscribe event = {0};
    if (sck == NULL || sck->fd > 0) return -1;

    /* init impl */
    memset(sck, 0, sizeof(*sck));
    
    /* create, bind and listen socket */
    if ((sck->fd = socket(PF_INET, SOCK_STREAM, IPPROTO_SCTP)) < 0)
    {
        perror("sctp socket failed");
    }

    /* socket bind */
    inet_addr_init(&sck->addr.in_addr, ip, port);
    socket_bind(sck->fd, (struct sockaddr *)&sck->addr.addr);

    /* init msg */
    initmsg.sinit_num_ostreams = 5;
    initmsg.sinit_max_instreams = 5;
    initmsg.sinit_max_attempts = 4;
    if (setsockopt(sck->fd, IPPROTO_SCTP, SCTP_INITMSG, &initmsg, sizeof(initmsg)) < 0)
        perror("sctp setsockopt initmsg failed");

    /* sctp event */
    event.sctp_data_io_event = 1;
    if (setsockopt(sck->fd, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(event)) < 0)
        perror("sctp setsockopt event failed");

    /* socket listen */
    socket_listen(sck->fd, 5);

    /* set socket block */
    make_socket_block(sck->fd);
   
    /* create tcp server thread runtine */
    if (pthread_create(&sck->ptd, NULL, tcp_server_backup_service, sck))

    {
        printf("sctp server create failed.\n");
        return -1;
    }

    return 0;
}

void server_init (unsigned port)
{
    unsigned sock;
    client_t client;

    _server_port = port;
    for (sock = 0; sock < MAX_SOCK_NUM; sock++) {
        client_init_sock (&client, sock);

        if (client_status (&client) == SnSR_CLOSED) {
            socket_init (sock, SnMR_TCP, port, 0);
            socket_listen (sock);
            _socket_port[sock] = port;
            break;
        }
    }
}

/*
  test that a server responds correctly to attempted name refresh requests
*/
static bool nbt_refresh_own(struct torture_context *tctx)
{
	struct nbt_name_refresh io;
	NTSTATUS status;
	struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL);
	const char *myaddress;
	struct socket_address *socket_address;
	struct nbt_name name;
	const char *address;

	if (!torture_nbt_get_name(tctx, &name, &address))
		return false;
	
	myaddress = iface_best_ip(address);

	socket_address = socket_address_from_strings(tctx, nbtsock->sock->backend_name,
						     myaddress, 0);
	torture_assert(tctx, socket_address != NULL, 
				   "Can't parse socket address");

	status = socket_listen(nbtsock->sock, socket_address, 0, 0);
	torture_assert_ntstatus_ok(tctx, status, 
							   "socket_listen for nbt_referesh_own failed");

	torture_comment(tctx, "Testing name defense to name refresh\n");

	io.in.name = name;
	io.in.dest_addr = address;
	io.in.address = myaddress;
	io.in.nb_flags = NBT_NODE_B | NBT_NM_ACTIVE;
	io.in.broadcast = False;
	io.in.ttl = 1234;
	io.in.timeout = 3;
	io.in.retries = 0;
	
	status = nbt_name_refresh(nbtsock, tctx, &io);

	torture_assert_ntstatus_ok(tctx, status, 
				talloc_asprintf(tctx, "Bad response from %s for name refresh", address));
	
	CHECK_STRING(tctx, io.out.name.name, name.name);
	CHECK_VALUE(tctx, io.out.name.type, name.type);
	CHECK_VALUE(tctx, io.out.rcode, NBT_RCODE_ACT);

	return true;
}

int nettest5(void)
{
	int err;
	sockaddr addr;
	int new_fd;

	fd = socket_create(SOCK_PROTO_TCP, 0);
	printf("created socket, fd %d\n", fd);
	if(fd < 0)
		return 0;

	memset(&addr, 0, sizeof(addr));
	addr.addr.len = 4;
	addr.addr.type = ADDR_TYPE_IP;
	addr.port = 1900;
	NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(0,0,0,0);

	err = socket_bind(fd, &addr);
	printf("socket_bind returns %d\n", err);
	if(err < 0)
		return 0;

	err = socket_listen(fd);
	printf("socket_listen returns %d\n", err);
	if(err < 0)
		return 0;

	new_fd = socket_accept(fd, &addr);
	printf("socket_accept returns %d\n", new_fd);
	if(new_fd < 0)
		return 0;

	err = socket_write(new_fd, "hello world!\n", strlen("hello world!\n"));
	printf("socket_write returns %d\n", err);

	printf("sleeping for 5 seconds\n");
	usleep(5000000);

	printf("closing fd %d\n", new_fd);
	socket_close(new_fd);
	printf("closing fd %d\n", fd);
	socket_close(fd);

	return 0;
}

void
f_socket_listen (void)
{
    int i, fd, port;
    char addr[ADDR_BUF_SIZE];

    fd = (sp - 1)->u.number;
    get_socket_address(fd, addr, &port, 0);

    if (VALID_SOCKET("listen")) {
	i = socket_listen(fd, sp);
	pop_stack();
        sp->u.number = i;
    } else {
	pop_stack();
        sp->u.number = EESECURITY;
    }
}

static void
listen_thread(void* arg)
{
    struct nr_mgr* mgr = (struct nr_mgr*)arg;

    sock client_fd = SOCKET_ERROR;
    struct sockaddr_in socketaddress;
    socklen_t size = sizeof(struct sockaddr);

    sock listen_fd = socket_listen(4002, 25);
    int total_num = 0;

    if(SOCKET_ERROR != listen_fd)
    {
        for(;;)
        {
            while((client_fd = accept(listen_fd, (struct sockaddr*)&socketaddress, &size)) < 0)
            {
                if(EINTR == sErrno)
                {
                    continue;
                }
            }

            if(SOCKET_ERROR != client_fd)
            {
                total_num++;
                //printf("accept %d, current total num : %d\n", client_fd, total_num);

                nrmgr_addfd(mgr, client_fd);
            }
        }

        socket_close(listen_fd);
        listen_fd = SOCKET_ERROR;
    }
    else
    {
        //printf("listen failed\n");
    }
    
    printf("exit\n");
    exit(0);
}

int main() {
    lib_init();

    list_t* list=list_new();

    lanser * freeLanser[10];

    for (int i = 0; i < 10; i++)
        freeLanser[i] = Freelanser_new();

  //  parse(freeLanser);

    socket_t * serverSocket = socket_new();
    socket_bind(serverSocket, 5000);
    socket_listen(serverSocket);


   while (1) {
        socket_t * clientSocket = socket_accept(serverSocket);

        char buf[10000]="";

        if (!socket_read(clientSocket, buf, sizeof(buf))) {
            puts("Skipping empty request");
            socket_close(clientSocket);
            socket_free(clientSocket);
            continue;
        }

        http_request_t req = http_request_parse(buf);

        server_answer(list,req,clientSocket,freeLanser);

        socket_close(clientSocket);
        socket_free(clientSocket);
    }

    socket_close(serverSocket);
    socket_free(serverSocket);

    lib_free();
    list_free(list);
    return 0;
}

/**
 * @brief start up a local server socket
 *
 * @param domain [in] This value can be AF_INET,AF_UNIX,AF_LOCAL,
 *                    PF_INET, PF_UINX and PF_LOCAL.
 * @param type   [in] can be SOCK_TREAM, SOCK_DGRAM.
 * @param path   [in] socket file path
 * @param is_ser [in] srever or client
 *
 * @return socket fd, if succ; exit, if fail
 */
int startup_local_server(int type, const char *path)
{
    int fd = -1;
    struct sockaddr_un addr = {0};
    
    /* init sockaddr_in */
    local_addr_init(&addr, path);
	
    /* create socket */
    fd = socket_create(AF_UNIX, type);
    make_listen_socket_reuseable(fd);
	unlink(addr.sun_path);
    
    /* bind and listen socket */
    socket_bind(fd, (struct sockaddr *)&addr);
    if (type == SOCK_STREAM) socket_listen(fd, 5);
	
    return fd;  
}

static int	init_socket(t_socket *sock, int port)
{
  if (socket_ctor(sock, AF_INET, SOCK_STREAM, 0) == RET_FAILURE)
    {
      perror("error: socket creation");
      return (RET_FAILURE);
    }
  if (socket_bind(sock, INADDR_ANY, port))
    {
      perror("error: socket bind");
      return (RET_FAILURE);
    }
  if (socket_listen(sock, 42) == RET_FAILURE)
    {
      perror("error: socket listen");
      return (RET_FAILURE);
    }
  return (RET_SUCCESS);
}

/**
 * Writes the received payload into payload argument and returns the tag of the message
 */
unsigned char server(unsigned char * payload)
{
    ulong msg_len = PAYLOAD_LEN + 1;
    unsigned char* msg = malloc(msg_len);

    // receive the message
    BIO * b = socket_listen();
    recv(b, msg, msg_len);
    // wait for the client to close, to avoid "Address already in use" errors
    wait_close(b);

    unsigned char * pad = otp(msg_len);         // apply the one-time pad
    xor(msg, pad, msg_len);

    // get the payload
    memcpy(payload, msg + 1, PAYLOAD_LEN);

    // return the tag
    return *msg;
}

static socket_t Listen(int port)
{
	int r;
	socket_t server;

	server = socket_tcp();
	if(socket_error == server)
		return socket_invalid;

	// reuse addr
	r = socket_setreuseaddr(server, 1);

	// bind
	r = socket_bind_any(server, (unsigned short)port);

	// listen
	r = socket_listen(server, 64);

	return server;
}

int main() {
    lib_init();
    socket_t * server = socket_new();
    socket_bind(server, 5000);
    socket_listen(server);
	
   char buf[10000];
    char pathBuf[256];
    socket_t * client = NULL;

    while(1) {
		client = socket_accept(server);
        socket_read(client, buf, sizeof(buf));
		if (strlen(buf) == 0)
			continue;
        printf(">> Got request:\n%s\n", buf);

        http_getPath(buf, pathBuf, sizeof(pathBuf));

        http_request_t request = http_request_parse(buf);

        if (strcmp(request.uri, "/") == 0) {
            server_homepage(client);
        } else if (strcmp(request.uri, "/database") == 0) {
            server_students(client, &request);
        }  
        else if (strcmp(request.uri, "/info") == 0) {
            server_info(client);
        }
        else if (strcmp(request.uri, "/filename") == 0) {
            server_file_parse(client);
        }
        else {
            server_notFound(client);
        }
		socket_free(client);
    }
    socket_free(server);
    lib_free();
    return 0;
}

/**
 * @brief start up a internet server socket
 *
 * @param domain [in] This value can be AF_INET,AF_UNIX,AF_LOCAL,
 *                    PF_INET, PF_UINX and PF_LOCAL.
 * @param type   [in] can be SOCK_TREAM, SOCK_DGRAM.
 * @param ip     [in] ip address, can be NULL
 * @param port   [in] socket port
 *
 * @return socket fd, if succ; exit, if fail
 */
int startup_inet_server(int type, const char *ip, \
						u_short port)
{
    int fd = -1;
    struct sockaddr_in addr = {0};
	
    /* create socket */
    fd = socket_create(AF_INET, type);
    make_listen_socket_reuseable(fd);
    
    /* init sockaddr_in */
    inet_addr_init(&addr, ip, port);
    
    /* bind socket */
    socket_bind(fd, (struct sockaddr *)&addr);
    
    /* build socket listen */
    if (type == SOCK_STREAM) socket_listen(fd, 5);

    return fd;
}

int qio_channel_socket_listen_sync(QIOChannelSocket *ioc,
                                   SocketAddress *addr,
                                   Error **errp)
{
    int fd;

    trace_qio_channel_socket_listen_sync(ioc, addr);
    fd = socket_listen(addr, errp);
    if (fd < 0) {
        trace_qio_channel_socket_listen_fail(ioc);
        return -1;
    }

    trace_qio_channel_socket_listen_complete(ioc, fd);
    if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) {
        close(fd);
        return -1;
    }

    return 0;
}

void StartServer(){
    int sockstat, listsock;

    listsock = socket_create(STREAM,"read_callback","close_callback");
    if(listsock < 0){
        debug("Couldn't create socket. errorcode: "+listsock);
        return;
    }

    sockstat = socket_bind(listsock,port);
    if(sockstat < 0){
        debug("Couldn't bind socket. errorcode: "+sockstat);
        return;
    }

    sockstat = socket_listen(listsock,"listen_callback");
    if(sockstat < 0){
        debug("Couldn't listen on socket. errorcode: "+sockstat);
        return;
    }

}