#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>

#include "encoding.h"
#include "platform.h"

#include "eos.h"
#include "log.h"
#include "msgq.h"
#include "event.h"

EOSMsgQ _eos_event_q;
static EOSMsgItem event_q_array[EOS_EVT_SIZE_Q];

static eos_evt_handler_t evt_handler[EOS_EVT_MAX];
static eos_evt_handler_global_t evt_handler_global;
static eos_evt_loopf_t evt_loop_f;

static void evtq_handler(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t _idx) {
    unsigned char idx = (type & EOS_EVT_MASK) >> 4;

    if (idx && (idx <= EOS_EVT_MAX)) {
        evt_handler[idx - 1](type, buffer, len);
    } else {
        eos_evtq_bad_handler(type, buffer, len);
    }
}

int eos_evtq_init(void) {
    int i;

    evt_handler_global = evtq_handler;
    for (i=0; i<EOS_EVT_MAX; i++) {
        evt_handler[i] = eos_evtq_bad_handler;
    }
    eos_msgq_init(&_eos_event_q, event_q_array, EOS_EVT_SIZE_Q);

    return EOS_OK;
}

int eos_evtq_len(void) {
    int rv;

    clear_csr(mstatus, MSTATUS_MIE);
    rv = eos_msgq_len(&_eos_event_q);
    set_csr(mstatus, MSTATUS_MIE);

    return rv;
}

int eos_evtq_push(unsigned char type, unsigned char *buffer, uint16_t len) {
    int rv;

    clear_csr(mstatus, MSTATUS_MIE);
    rv = eos_msgq_push(&_eos_event_q, type, buffer, len);
    set_csr(mstatus, MSTATUS_MIE);

    return rv;
}

int eos_evtq_push_widx(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t *idx) {
    int rv;

    clear_csr(mstatus, MSTATUS_MIE);
    rv = eos_msgq_push_widx(&_eos_event_q, type, buffer, len, idx);
    set_csr(mstatus, MSTATUS_MIE);

    return rv;
}

int eos_evtq_push_isr(unsigned char type, unsigned char *buffer, uint16_t len) {
    return eos_msgq_push(&_eos_event_q, type, buffer, len);
}

int eos_evtq_push_widx_isr(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t *idx) {
    return eos_msgq_push_widx(&_eos_event_q, type, buffer, len, idx);
}

void eos_evtq_pop(unsigned char *type, unsigned char **buffer, uint16_t *len) {
    clear_csr(mstatus, MSTATUS_MIE);
    eos_msgq_pop(&_eos_event_q, type, buffer, len);
    set_csr(mstatus, MSTATUS_MIE);
}

void eos_evtq_pop_widx(unsigned char *type, unsigned char **buffer, uint16_t *len, uint8_t *idx) {
    clear_csr(mstatus, MSTATUS_MIE);
    eos_msgq_pop_widx(&_eos_event_q, type, buffer, len, idx);
    set_csr(mstatus, MSTATUS_MIE);
}

void eos_evtq_pop_isr(unsigned char *type, unsigned char **buffer, uint16_t *len) {
    eos_msgq_pop(&_eos_event_q, type, buffer, len);
}

void eos_evtq_pop_widx_isr(unsigned char *type, unsigned char **buffer, uint16_t *len, uint8_t *idx) {
    eos_msgq_pop_widx(&_eos_event_q, type, buffer, len, idx);
}

int eos_evtq_get(unsigned char type, unsigned char **buffer, uint16_t *len) {
    int rv = 0;

    clear_csr(mstatus, MSTATUS_MIE);
    rv = eos_msgq_find(&_eos_event_q, type, NULL, 0, buffer, len);
    set_csr(mstatus, MSTATUS_MIE);

    return rv;
}

int eos_evtq_find(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len) {
    int rv = 0;

    clear_csr(mstatus, MSTATUS_MIE);
    rv = eos_msgq_find(&_eos_event_q, type, selector, sel_len, buffer, len);
    set_csr(mstatus, MSTATUS_MIE);

    return rv;
}

int eos_evtq_wait(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len) {
    int rv = 0;

    while(!rv) {
        clear_csr(mstatus, MSTATUS_MIE);
        rv = eos_msgq_find(&_eos_event_q, type, selector, sel_len, buffer, len);
        if (rv && (rv != EOS_ERR_NOTFOUND)) {
            set_csr(mstatus, MSTATUS_MIE);
            return rv;
        }
        if (rv) {
            unsigned char _type;
            unsigned char *_buffer;
            uint16_t _len;
            uint8_t idx;

            eos_msgq_pop_widx(&_eos_event_q, &_type, &_buffer, &_len, &idx);
            if (_type) {
                set_csr(mstatus, MSTATUS_MIE);
                evt_handler_global(_type, _buffer, _len, idx);
            } else {
                asm volatile ("wfi");
                set_csr(mstatus, MSTATUS_MIE);
            }
        } else {
            set_csr(mstatus, MSTATUS_MIE);
        }
    }
}

void eos_evtq_flush(void) {
    clear_csr(mstatus, MSTATUS_MIE);
    eos_evtq_flush_isr();
    set_csr(mstatus, MSTATUS_MIE);
}

void eos_evtq_flush_isr(void) {
    unsigned char type;
    unsigned char *buffer;
    uint16_t len;
    uint8_t idx;

    do {
        eos_msgq_pop_widx(&_eos_event_q, &type, &buffer, &len, &idx);
        if (type) {
            set_csr(mstatus, MSTATUS_MIE);
            evt_handler_global(type, buffer, len, idx);
            clear_csr(mstatus, MSTATUS_MIE);
        }
    } while (type);
}

void eos_evtq_loop(void) {
    int foo = 1;

    while(foo) {
        eos_evtq_exec();
        if (evt_loop_f) evt_loop_f();
    }
}

void eos_evtq_exec(void) {
    unsigned char type;
    unsigned char *buffer;
    uint16_t len;
    uint8_t idx;

    clear_csr(mstatus, MSTATUS_MIE);
    eos_msgq_pop_widx(&_eos_event_q, &type, &buffer, &len, &idx);
    if (type) {
        set_csr(mstatus, MSTATUS_MIE);
        evt_handler_global(type, buffer, len, idx);
    } else {
        asm volatile ("wfi");
        set_csr(mstatus, MSTATUS_MIE);
    }
}

void eos_evtq_set_loopf(eos_evt_loopf_t loop_f) {
    evt_loop_f = loop_f;
}


void eos_evtq_bad_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
    EOS_LOG(EOS_LOG_ERR, "EVT BAD HANDLER:0x%.2X\n", type);
}

void eos_evtq_set_handler(unsigned char type, eos_evt_handler_t handler) {
    unsigned char idx = (type & EOS_EVT_MASK) >> 4;

    if (handler == NULL) handler = eos_evtq_bad_handler;
    if (idx && (idx <= EOS_EVT_MAX)) evt_handler[idx - 1] = handler;
}

eos_evt_handler_t eos_evtq_get_handler(unsigned char type) {
    unsigned char idx = (type & EOS_EVT_MASK) >> 4;

    if (idx && (idx <= EOS_EVT_MAX)) return evt_handler[idx - 1];
    return NULL;
}

void eos_evtq_set_handler_global(eos_evt_handler_global_t handler) {
    evt_handler_global = handler;
}

eos_evt_handler_global_t eos_evtq_get_handler_global(void) {
    return evt_handler_global;
}