#include <sys/types.h>
#include <sys/event.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <syslog.h>
#include <libgen.h>
#include <launch.h>
#include <os/log.h>
 

int main(void)
{
    struct sockaddr_storage ss;
    socklen_t slen = sizeof(ss);
    struct kevent kev_init;
    struct kevent kev_listener;
    launch_data_t sockets_dict;
    launch_data_t checkin_response;
    launch_data_t checkin_request;
    //launch_data_t listening_fd_array;
    int *listening_fd_array;
    size_t launchd_fds_count;	// launch_activate_socket
    int err;			// launch_activate_socket

    size_t i;
    int kq;
    int retval = EXIT_SUCCESS;
 
    /*
     * Create a new kernel event queue
     * that we'll use for our notification.
     *
         * Note the use of the '%m' formatting character.
         * ASL will replace %m with the error string associated 
         * with the current value of errno.
         */

    if (-1 == (kq = kqueue())) {
        os_log_error(OS_LOG_DEFAULT, "kqueue(): %m");
        retval = EXIT_FAILURE;
        goto done;
    }

    /*
     * Launchd Check-in - ask for out socket
     */

    err = launch_activate_socket("MyListenerSocket", &listening_fd_array, &launchd_fds_count);
    if (err != 0) { 
        os_log_error(OS_LOG_DEFAULT, "launch_activate_socket() failed error %d (%s)", err, strerror(err)); 
    }
    else
        os_log_error(OS_LOG_DEFAULT, "launch_activate_socket() succeeded Sockets %zu", launchd_fds_count); 

    if (NULL == listening_fd_array) {
        os_log_error(OS_LOG_DEFAULT, "No known sockets found to answer requests on!");
        retval = EXIT_FAILURE;
        goto done;
    }

    /*
     * Initialize a new kernel event.  This will trigger when
     * a connection occurs on our listener socket.
     */

    for (i = 0; i < launchd_fds_count; i++) {
        int *this_listening_fd = &listening_fd_array[i];
        EV_SET(&kev_init, *this_listening_fd, EVFILT_READ, EV_ADD, 0, 0, NULL);

        if (kevent(kq, &kev_init, 1, NULL, 0, NULL) == -1) {
            os_log_error(OS_LOG_DEFAULT, "kevent(): %m");
            retval = EXIT_FAILURE;
            goto done;
        }
    }

    for (;;) {

        FILE *the_stream;
        int filedesc, gai_r;
        char nodename[1024];
        char servname[1024];

        /*
         * Get the next event from the kernel event queue.
         */

        if ((filedesc = kevent(kq, NULL, 0, &kev_listener, 1, NULL)) == -1) {
            os_log_error(OS_LOG_DEFAULT, "kevent(): %m");
            retval = EXIT_FAILURE;
            goto done;

        } else if (filedesc == 0) {
            retval = EXIT_SUCCESS;
            goto done;
        }

        /*
         * Accept an incoming connection.
         */

        if ((filedesc = accept(kev_listener.ident, (struct sockaddr *)&ss, &slen)) == -1) {
            os_log_error(OS_LOG_DEFAULT, "accept(): %m");
            continue; /* this isn't fatal */
        }
 
        /*
         * Extract the client's host and port names so we 
         * can print them out.
         */

        gai_r = getnameinfo((struct sockaddr *)&ss, slen, nodename, sizeof(nodename),
                servname, sizeof(servname), NI_NUMERICSERV | NI_NUMERICHOST);

        if (0 != gai_r) {
            /* Error occured - log it */
            os_log_error(OS_LOG_DEFAULT, "getnameinfo(): %s", gai_strerror(gai_r));

        } else {

            /*
             * Send our log message off to the syslogd server.  
             */

            os_log_with_type(OS_LOG_DEFAULT, OS_LOG_TYPE_DEFAULT, "Connection established (IP: %{public}s ; Port: %{public}s)", nodename, servname);
        }

        /*
         * Open the stream and message the client. 
         */

        the_stream = fdopen(filedesc, "r+");
        os_log_with_type(OS_LOG_DEFAULT, OS_LOG_TYPE_DEFAULT, "got file descriptor %d", filedesc);

        if (the_stream) {
            fprintf(the_stream, "Hello C World!\n");
            fclose(the_stream);

        } else {
            close(filedesc);
        }
    }
done:
    return retval;
}