/*
 * DEBUGGER code
 * 
 * On "publish", when buffer is free, debugger stores arbitrary variables 
 * content into, and mark this buffer as filled
 * 
 * 
 * Buffer content is read asynchronously, (from non real time part), 
 * and then buffer marked free again.
 *  
 * 
 * */
#include "iec_types_all.h"
#include "POUS.h"
/*for memcpy*/
#include <string.h>
#include <stdio.h>

#define BUFFER_SIZE %(buffer_size)d
#define MAX_SUBSCRIBTION %(subscription_table_count)d

/* Atomically accessed variable for buffer state */
#define BUFFER_FREE 0
#define BUFFER_BUSY 1
static long buffer_state = BUFFER_FREE;

/* The buffer itself */
char debug_buffer[BUFFER_SIZE];

/* Buffer's cursor*/
static char* buffer_cursor = debug_buffer;

typedef struct{
    void* ptrvalue;
    __IEC_types_enum type;
}struct_plcvar;

/***
 * Declare programs 
 **/
%(programs_declarations)s

/***
 * Declare global variables from resources and conf 
 **/
%(extern_variables_declarations)s

static int subscription_table[MAX_SUBSCRIBTION];
static int* latest_subscription = subscription_table;
static int* subscription_cursor = subscription_table;

struct_plcvar variable_table[%(variables_pointer_type_table_count)d];

void __init_debug(void)
{
%(variables_pointer_type_table_initializer)s
    buffer_state = BUFFER_FREE;
}

void __cleanup_debug(void)
{
}

void __retrieve_debug(void)
{
}

extern int TryEnterDebugSection(void);
extern void LeaveDebugSection(void);
extern long AtomicCompareExchange(long*, long, long);
extern void InitiateDebugTransfer(void);

extern unsigned long __tick;
void __publish_debug(void)
{
    /* Check there is no running debugger re-configuration */
    if(TryEnterDebugSection()){
        /* Lock buffer */
        long latest_state = AtomicCompareExchange(
            &buffer_state,
            BUFFER_FREE,
            BUFFER_BUSY);
            
        /* If buffer was free */
        if(latest_state == BUFFER_FREE)
        {
            int* subscription;
            
            /* Reset buffer cursor */
            buffer_cursor = debug_buffer;
            
            /* iterate over subscriptions */
            for(subscription=subscription_table;
                subscription < latest_subscription;
                subscription++)
            {
                /* get variable descriptor */
                struct_plcvar* my_var = &variable_table[*subscription];
                char* next_cursor;
                /* get variable size*/
                USINT size = __get_type_enum_size(my_var->type);
                /* compute next cursor positon*/
                next_cursor = buffer_cursor + size;
                /* if buffer not full */
                if(next_cursor <= debug_buffer + BUFFER_SIZE)
                {
                    /* copy data to the buffer */
                    memcpy(buffer_cursor, my_var->ptrvalue, size);
                    /* increment cursor according size*/
                    buffer_cursor = next_cursor;
                }else{
                    /*TODO : signal overflow*/
                }
            }
    
            /* Reset buffer cursor again (for IterDebugData)*/
            buffer_cursor = debug_buffer;
            subscription_cursor = subscription_table;
            
            /* Leave debug section,
             * Trigger asynchronous transmission 
             * (returns immediately) */
            InitiateDebugTransfer(); /* size */
        }
        LeaveDebugSection();
    }
}

void RegisterDebugVariable(int idx)
{
    /*If subscription table not full */
    if(latest_subscription - subscription_table < MAX_SUBSCRIBTION)
    {
        *(latest_subscription++) = idx;
        /* TODO pre-calc buffer size and signal overflow*/
    }else{
        /*TODO : signal subscription overflow*/
    }
}

void ResetDebugVariables(void)
{
    latest_subscription = subscription_table;
}

void FreeDebugData(void)
{
    /* atomically mark buffer as free */
    long latest_state;
    latest_state = AtomicCompareExchange(
        &buffer_state,
        BUFFER_BUSY,
        BUFFER_FREE);
}

void* IterDebugData(int* idx, const char **type_name)
{
	struct_plcvar* my_var;
	USINT size;
    if(subscription_cursor < latest_subscription){
        char* old_cursor = buffer_cursor;
        *idx = *subscription_cursor;
        my_var = &variable_table[*(subscription_cursor++)];
        *type_name = __get_type_enum_name(my_var->type);
        /* get variable size*/
        size = __get_type_enum_size(my_var->type);
        /* compute next cursor position*/
        buffer_cursor = buffer_cursor + size;
        if(old_cursor < debug_buffer + BUFFER_SIZE)
        {
            return old_cursor;
        }else{
            //printf("%%d > %%d\n", old_cursor - debug_buffer, BUFFER_SIZE);
            return NULL;
        } 
    }
    *idx = -1;
    *type_name = NULL;
    return NULL;
}