#include "nv.h"

#include "assoc.h"

#include "node.h"

#include "network.h"

#include "power.h"

#include "tidsense.h"

#include "debug.h"

#include "report.h"

static void report_confirm(NWK_DataReq_t *req) {

    static uint8_t error_count = 0;

    switch(req->status) {

        case NWK_SUCCESS_STATUS:

            app_handle_ack(req->control);

            error_count = 0;

            break;

        case NWK_ERROR_STATUS:

        case NWK_NO_ACK_STATUS:

        case NWK_PHY_NO_ACK_STATUS:

            error_count++;

            debugf("nwk: no reply from 0x%04X\n", req->dstAddr);

            break;

        default:

            error_count++;

            debugf("nwk: unhandled status %d\n", req->status);

            break;

    }

    network_free_request(req);

    if(error_count >= 16) {

        //assoc_unassociate();

        error_count = 0;

    }

}

bool report_start(report_t *r, uint16_t ns) {

    r->req = network_alloc_request(30);

    if(!r->req) return false;

    r->msg = (sensor_msg_t*)&r->req->data[0];

    r->payload = r->msg->payload;

    r->payload_size = 0;

    r->msg->sensor_cmd = SENSOR_CMD_DATA_V2;

    r->msg->next_hop = 0xFFFF;

    r->msg->ns = ns;

    return true;

}

bool report_add_payload(report_t *r, sensor_flags_t type, void *sample) {

    uint8_t *p = (uint8_t*)r->payload;

    if(r->payload_size + sizeof(sensor_flags_t) + SENSOR_SIZE(type) >

       SENSOR_MAX_PAYLOAD_SIZE) {

        return false;

    }

    *(sensor_flags_t*)p = type;

    p += sizeof(sensor_flags_t);

    r->payload_size += sizeof(sensor_flags_t);

    switch(type & SENSOR_SIZE_bm) {

        case SENSOR_SIZE_8BIT:

            *(uint8_t*)p = *(uint8_t*)sample;

            p += sizeof(uint8_t);

            r->payload_size += sizeof(uint8_t);

            break;

        case SENSOR_SIZE_16BIT:

            *(uint16_t*)p = *(uint16_t*)sample;

            p += sizeof(uint16_t);

            r->payload_size += sizeof(uint16_t);

            break;

        case SENSOR_SIZE_32BIT:

            *(uint32_t*)p = *(uint32_t*)sample;

            p += sizeof(uint32_t);

            r->payload_size += sizeof(uint32_t);

            break;

    }

    r->payload = (void*)p;

    return true;

}

void report_send(report_t *r) {

    power_radio_on();

    uint16_t dest = nv_get_word(default_basestation);

    if(assoc_get_state() == ASSOC_STATE_ASSOCIATED) {

        dest = assoc_get_master();

    }

    r->msg->next_hop = NWK_RouteNextHop(dest, 0);

    r->req->dstAddr = dest;

    r->req->dstEndpoint = SENSOR_DATA_ENDPOINT;

    r->req->srcEndpoint = SENSOR_DATA_ENDPOINT;

    r->req->options = NWK_OPT_ACK_REQUEST;

    r->req->size = SENSOR_HEADER_SIZE + r->payload_size;

    r->req->confirm = report_confirm;

    NWK_DataReq(r->req);

    r->payload_size = 0;

    r->msg = NULL;

    r->req = NULL;

    r->payload = NULL;

}