#pragma once

#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include <hwo/serial.h>
#include <hwo/chksum.h>
#include <hwo/threads.h>
#include <hwo/systick.h>

#include <sys/errno.h>
#include <sys/mutex.h>
#include <util/list.h>

#include <io/usart.h>

/***********************************
	rb2/regbus.h
	
	RegisteredBus2

	Paketorientierte Kommunikation via Serielle Verbindungen mit Adressierung	
	
***********************************/

extern RB2_INSTANCE	__rb2_instance;

int rb2_request	(RB2_ADDR receiver,uint16_t registerno,uint8_t type,void *data);

static inline int rb2_read_int32(RB2_ADDR receiver,uint16_t registerno,int32_t *i32) {
	return rb2_request(receiver,registerno,RDT_INT32,i32);
};
static inline int rb2_read_float(RB2_ADDR receiver,uint16_t registerno,float *f32) {
	return rb2_request(receiver,registerno,RDT_FLOAT,f32);
};

static inline int rb2_write_int32(RB2_ADDR receiver,uint16_t registerno,int32_t *i32) {
	return rb2_request(receiver,registerno,RDT_INT32 | RDT_WRITE,i32);
};
static inline int rb2_write_float(RB2_ADDR receiver,uint16_t registerno,float *f32) {
	return rb2_request(receiver,registerno,RDT_FLOAT | RDT_WRITE,f32);
};

static inline int rb2_write_int32_d(RB2_ADDR receiver,uint16_t registerno,int32_t i32) {
	return rb2_request(receiver,registerno,RDT_INT32 | RDT_WRITE,&i32);
};
static inline int rb2_write_float_d(RB2_ADDR receiver,uint16_t registerno,float f32) {
	return rb2_request(receiver,registerno,RDT_FLOAT | RDT_WRITE,&f32);
};

//static inline RB2_INSTANCE* rb2_instance(void) { return &__rb2_instance; };
#define rb2_instance() (&__rb2_instance)

static inline uint8_t rb2_first_id(void) { return (__rb2_instance.proxy.next) ? RB2_PROXY(__rb2_instance.proxy.next)->id : 0 ; };

static inline uint8_t rb2_request_is_local(RB2_TELEGRAM *telegram) {
	if ( ((telegram->receiver.ax == __rb2_instance.ax)||(telegram->receiver.ax==0)) && (__rb2_instance.idmask & (1<<telegram->receiver.node)) ){
		return -1;
	};
	
	return 0;
};


static inline void rb2_proxy_init(RB2_PROXY *proxy) {
	memset( proxy, 0x00, sizeof(RB2_PROXY) );
	list_init( &proxy->segments );
};

static inline void rb2_add_proxy(RB2_PROXY *proxy) {
	list_append( &(proxy->list), &((&__rb2_instance)->proxy) );
	__rb2_instance.idmask |= (1 << proxy->id);
};

static inline void rb2_remove_proxy(RB2_PROXY *proxy) {
	list_remove( &(proxy->list) );
	__rb2_instance.idmask &= ~(1 << proxy->id);
};

static inline void rb2_add_rsegment(RB2_PROXY *proxy,RB2_RSEGMENT *segment) {
	list_append( &segment->list, &proxy->segments );
};

static inline RB2_PROXY* rb2_get_proxy(uint8_t id) {
	list_t* i;
	
	for_each_list_entry(i,&((&__rb2_instance)->proxy)){
		RB2_PROXY *p = list_entry(i,RB2_PROXY,list);
		if (p->id == id){
			return p;
		}
	};
	return NULL;
};


uint8_t rb2_init		(uint8_t ax);
void	rb2_loop		(void* arg);				// Management Thread
void	rb2_loop_rx		();
void	rb2_loop_tx		();
void	rb2_loop_ident	();

void 	rb2_handle_request(rb2_telegram_buffer_t *telegram);
void 	rb2_handle_response(rb2_telegram_buffer_t *telegram);

void	rb2_route		(RB2_TELEGRAM *request);
void	rb2_route_listed(rb2_telegram_buffer_t *txtele);
void	rb2_router		(void *arg);

int rb2_build_request	(RB2_REQUEST *request,RB2_ADDR receiver,uint16_t registerno,uint8_t type,void *data);
int rb2_enqueue_pending	(RB2_REQUEST *request);
int rb2_unqueue_pending	(RB2_REQUEST *request);

RB2_LINK*	rb2_create_stream_link(FILE *stream);
RB2_LINK*	rb2_create_usart_link(uint8_t _usart);

uint16_t
		rb2_known_endpoints(void);


void	rb2_api_rx		(rb2_telegram_buffer_t *telegram);
void	rb2_convert		(uint8_t srctype,void *src,uint8_t dsttype, void *dst);

uint8_t	rb2_default_register_proc(RB2_REGISTER *reg,RB2_TELEGRAM *telegram);


static inline int		rb2_link_add	(RB2_LINK *link){
	cpustate_t state;
	
	spinlock_lock_irq( &__rb2_instance.links.lock, &state );
	list_append( &(link->list), &(__rb2_instance.links.list) );
	spinlock_release_irq( &__rb2_instance.links.lock, &state );
	
	return ESUCCESS;
};

rb2_telegram_buffer_t*	rb2_pool_pop	(void);
rb2_telegram_buffer_t*	rb2_pool_pop_irq(void);
void					rb2_pool_push	(rb2_telegram_buffer_t *tele);


/* DEBUG / Tracing */

void _dbg_trace_rb2_usart_tx(rb2_telegram_buffer_t *telegram) __attribute__(( weak ));
void _dbg_trace_rb2_usart_rx(rb2_telegram_buffer_t *telegram) __attribute__(( weak ));

void _dbg_trace_rb2_can_tx(rb2_telegram_buffer_t *telegram) __attribute__(( weak ));
void _dbg_trace_rb2_can_rx(rb2_telegram_buffer_t *telegram) __attribute__(( weak ));

extern int32_t	_dbg_rb2_usart_sync,
				_dbg_rb2_usart_sync_min,
				_dbg_rb2_usart_sync_max;
extern int32_t	_dbg_rb2_usart_txtele,
				_dbg_rb2_usart_rxtele;