#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <unistd.h>

#include <OS.h>


static sem_id sSemaphore1;
static sem_id sSemaphore2;
static port_id sPort1;
static port_id sPort2;


static status_t
notifier_thread(void* data)
{
        snooze(1000000);
        release_sem(sSemaphore1);
        snooze(1000000);
        release_sem(sSemaphore2);
        snooze(1000000);
        write_port(sPort1, 0xcafe, "test", 4);
        snooze(1000000);
        int32 code;
        read_port(sPort2, &code, &code, sizeof(code));
        snooze(1000000);

        return B_OK;
}


static void
print_events(const object_wait_info* infos, int infoCount)
{
        printf("events:\n");
        for (int i = 0; i < infoCount; i++)
                printf("  %d: 0x%x\n", i, infos[i].events);
}


int
main()
{
        sSemaphore1 = create_sem(0L, "test semaphore 1");
        sSemaphore2 = create_sem(0L, "test semaphore 2");
        sPort1 = create_port(2L, "test port 1");
        sPort2 = create_port(1L, "test port 2");

        printf("semaphore 1: %ld\n", sSemaphore1);
        printf("semaphore 2: %ld\n", sSemaphore2);
        printf("port 1:      %ld\n", sPort1);
        printf("port 2:      %ld\n", sPort2);

        thread_id thread = spawn_thread(notifier_thread, "notifier",
                B_NORMAL_PRIORITY, NULL);
        resume_thread(thread);

        printf("thread:      %ld\n", thread);

        object_wait_info initialInfos[] = {
                {
                        sSemaphore1,
                        B_OBJECT_TYPE_SEMAPHORE,
                        B_EVENT_ACQUIRE_SEMAPHORE
                },
                {
                        sSemaphore2,
                        B_OBJECT_TYPE_SEMAPHORE,
                        B_EVENT_ACQUIRE_SEMAPHORE
                },
                {
                        sPort1,
                        B_OBJECT_TYPE_PORT,
                        B_EVENT_READ
                },
                {
                        sPort2,
                        B_OBJECT_TYPE_PORT,
                        B_EVENT_WRITE
                },
                {
                        0,
                        B_OBJECT_TYPE_FD,
                        B_EVENT_READ
                },
                {
                        thread,
                        B_OBJECT_TYPE_THREAD,
                        B_EVENT_INVALID
                }
        };
        int infoCount = sizeof(initialInfos) / sizeof(object_wait_info);

        while (true) {
                object_wait_info infos[infoCount];
                memcpy(infos, initialInfos, sizeof(initialInfos));

                ssize_t result = wait_for_objects_etc(infos, infoCount,
                        B_RELATIVE_TIMEOUT, 10000000LL);

                if (result >= 0)
                        printf("\nwait_for_objects(): %ld\n", result);
                else
                        printf("\nwait_for_objects(): %s\n", strerror(result));

                print_events(infos, infoCount);

                for (int i = 0; i < infoCount; i++) {
                        int32 type = infos[i].type;
                        int32 object = infos[i].object;
                        uint16 events = infos[i].events;
                        char buffer[256];

                        if (type == B_OBJECT_TYPE_SEMAPHORE) {
                                if (events & B_EVENT_ACQUIRE_SEMAPHORE) {
                                        status_t error = acquire_sem_etc(object, 1,
                                                B_RELATIVE_TIMEOUT, 0);
                                        printf("acquire_sem(%ld): %s\n", object, strerror(error));
                                }
                        } else if (type == B_OBJECT_TYPE_PORT) {
                                if (events & B_EVENT_READ) {
                                        int32 code;
                                        ssize_t bytesRead = read_port_etc(object, &code,
                                                buffer, sizeof(buffer), B_RELATIVE_TIMEOUT, 0);
                                        printf("read_port(%ld): %ld\n", object, bytesRead);
                                }
                                if (events & B_EVENT_WRITE) {
                                        status_t error = write_port_etc(object, 0xc0de, buffer, 10,
                                                B_RELATIVE_TIMEOUT, 0);
                                        printf("write_port(%ld): %s\n", object, strerror(error));
                                }
                        } else if (type == B_OBJECT_TYPE_FD) {
                                if (events & B_EVENT_READ) {
                                        ssize_t bytesRead = read(object, buffer, sizeof(buffer));
                                        printf("read(%ld): %ld\n", object, bytesRead);
                                }
                        } else if (type == B_OBJECT_TYPE_THREAD) {
                                if (events & B_EVENT_INVALID) {
                                        printf("thread %ld quit\n", object);
                                        infoCount--;
                                }
                        }
                }
        }

        return 0;
}