#include "config.h"

#include <stdlib.h>

#include <string.h>

#include "scheduler.h"

#include "power.h"

#include "node.h"

#include "network.h"

#include "assoc.h"

#include "sysclock.h"

#include "event.h"

sched_task_t *event_task;

event_record_t event_buffer[MAX_EVENTS];

uint8_t event_flags = 0;

bool events_with_status(event_status_t status) {

    for(uint8_t i=0; i<MAX_EVENTS; i++) {

        if(event_buffer[i].status == status) {

            return true;

        }

    }

    return false;

}

void event_mark_transmitted(event_status_t status) {

    for(uint8_t i=0; i<MAX_EVENTS; i++) {

        if(event_buffer[i].status == EVENT_TRANSMITTED) {

            event_buffer[i].status = status;

        }

    }

}

void event_confirm(NWK_DataReq_t *req) {

    if(req->status == NWK_SUCCESS_STATUS) {

        event_mark_transmitted(EVENT_FREE);

        event_flags = 0;

    } else {

        event_mark_transmitted(EVENT_PENDING);

        event_flags |= EVENT_FLAG_RETRANSMIT;

    }

    network_free_request(req);

}

void event_task_fn(void *data) {

    // only if we have a master

    if(assoc_get_state() != ASSOC_STATE_ASSOCIATED) return;

    if(!events_with_status(EVENT_PENDING)) return;

    // Don't continue if there are currently events in the air

    if(events_with_status(EVENT_TRANSMITTED)) return;

    NWK_DataReq_t *req = network_alloc_request(1);

    if(!req) return;

    power_radio_on();

    req->dstAddr = assoc_get_master();

    req->dstEndpoint = CONTROL_ENDPOINT;

    req->srcEndpoint = CONTROL_ENDPOINT;

    req->options = NWK_OPT_ACK_REQUEST;

    req->confirm = event_confirm;

    req->size = sizeof(event_report_t);

    event_report_t *report = (event_report_t*)req->data;

    report->header.cmd = CMD_EVENT_REPORT;

    report->header.flags = 0;

    report->header.id = cmd_get_next_id();

    report->n = 0;

    report->flags = event_flags;

    sysclock_get_time(&report->timestamp, NULL);

    for(uint8_t i=0; i<MAX_EVENTS; i++) {

        event_record_t *e = &event_buffer[i];

        if(e->status == EVENT_PENDING) {

            e->status = EVENT_TRANSMITTED;

            memcpy(&req->data[req->size], e, sizeof(event_record_t));

            req->size += sizeof(event_record_t);

            report->n++;

        }

        // keep from overfilling a packet; events not sent here will get

        // handled on the next iteration

        if(req->size >= 100) break;

    }

    NWK_DataReq(req);

}

event_record_t *event_get_free(void) {

    event_record_t *oldest = NULL;

    uint32_t oldest_ts = 2147483647UL;

    for(uint8_t i=0; i<MAX_EVENTS; i++) {

        event_record_t *e = &event_buffer[i];

        if(e->status == EVENT_FREE) return e;

        if(e->timestamp < oldest_ts) {

            oldest = e;

            oldest_ts = e->timestamp;

        }

    }

    event_flags |= EVENT_FLAG_OVERFLOW;

    oldest->status = EVENT_FREE;

    return oldest;

}   

void event_create(event_type_t event, uint32_t data, uint8_t priority) {

    event_record_t *e = event_get_free();

    e->status = EVENT_PENDING;

    e->event = event;

    e->data = data;

    e->priority = priority;

    sysclock_get_time(&e->timestamp, NULL);

}

void event_setup(void) {

    for(uint8_t i=0; i<MAX_EVENTS; i++) {

        event_buffer[i].status = EVENT_FREE;

    }

    event_flags = 0;

    event_task = sched_task_create(event_task_fn, NULL, 30, 0, SCHED_ENABLED | SCHED_RUN_IDLE);

}