/*
    This file is part of libcapwap.

    libcapwap is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    libcapwap is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Foobar.  If not, see <http://www.gnu.org/licenses/>.

*/




/**
 * @file Debugging Functions
 * @brief Various debug functions.
 */
#include <stdarg.h>
#include <stdint.h>

#include "dbg.h"
#include "log.h"
#include "format.h"
#include "ansi_colors.h"

#include "dot11.h"

/**
 *@addtogroup DBG
 *@{
 */

 /*
  * @defgroup DebugFunctions Debug Functions
  * @{
  */

uint32_t cw_dbg_opt_display = DBG_DISP_COLORS;

/**
 * Current debug level
 */
//static uint32_t cw_dbg_opt_level = 0;
//
static struct mavl * cw_dbg_opt_level = NULL;
static int dbg_cmp(const void *a, const void*b)
{
	return (*((int*)a)-*((int*)b));
}


struct cw_DbgStr {
	int level;
	const char *str;
	const char ** str_list;
	const char *descr;
};


static const char * dbg_level_msg[] = {
	"msg_in", "msg_out", NULL
};

static const char * dbg_level_pkt[] = {
	"pkt_in", "pkt_out",  NULL
};

static const char * dbg_level_elem[]={
	"elem_in","elem_out",NULL
};

static const char * dbg_level_elem_detail[] = {
	"elem_detail_in", "elem_detail_out", NULL
};

static const char * dbg_level_elem_dmp[] = {
	"elem_dmp_in", "elem_dmp_out", NULL
};
	
static const char * dbg_level_elem_all[] = {
	"elem", "elem_dmp", "elem_detail",NULL
};

static const char * dbg_level_std[] = {
	"msg","elem","msg_err", "elem_err", "pkt_err", "rfc", "warn", "state", "info", NULL
/*		
	DBG_MSG_IN, DBG_MSG_OUT,
	DBG_ELEM_IN, DBG_ELEM_OUT,
	DBG_MSG_ERR, DBG_ELEM_ERR,
	DBG_PKT_ERR, DBG_RFC, DBG_WARN,
	DBG_STATE, DBG_INFO,
	0*/
};


/**
 * Debug strings
 */
struct cw_DbgStr cw_dbg_strings[] = {
	{ 0, 			"std", dbg_level_std, "some useful standard options to debug CAPWAP"},
	{ 0,			"msg", dbg_level_msg, "messages headers" },
	{ 0,			"pkt", dbg_level_pkt, "packet headers" },
	{ 0,			"elem", dbg_level_elem, "message elemenst" },
	{ 0, 			"elem_detail", dbg_level_elem_detail, "details for message elements"},
	{ 0, 			"elem_dmp", dbg_level_elem_dmp,"hexdump element"},
	{ 0, 			"elem_all", dbg_level_elem_all,"all possible elem options"},

	{ DBG_WARN,		"warn", NULL, "warnings" },

	{ DBG_ELEM_ERR, 	"elem_err", NULL, "errors in elements" },
	{ DBG_PKT_ERR,		"pkt_err", NULL, "packets with errors which are usually would be discard" },
	{ DBG_MSG_ERR,		"msg_err", NULL, "message errors"},
	{ DBG_RFC,		"rfc", NULL, "errors related to RFC5415/RFC5416 viloations" },
	{ DBG_CFG_UPDATES, 	"cfg_updates",NULL, "show configuration aupdates" },
	{ DBG_MOD,		"mod",NULL, "module related"},
	{ DBG_MOD_DETAIL,	"mod_detail",NULL, "module related details"},
	{ DBG_STATE,		"state",NULL, "CAWPAP states" },
	{ DBG_MSG_COMPOSE,	"msg_compose",NULL,"message composing details" },


	{ DBG_INFO,		"info", NULL, "several infos are displayed" },
	{ DBG_PKT_IN,		"pkt_in",NULL, "headers of incomming packets."  },
	{ DBG_PKT_OUT,		"pkt_out",NULL, "headers out outgoing packets." },
	{ DBG_PKT_DMP_IN,	"pkt_dmp_in",NULL, "hex-dump incomming packets" },
	{ DBG_PKT_DMP_OUT,	"pkt_dmp_out",NULL, "hex-dump outgoing packets"  },

	{ DBG_MSG_IN,		"msg_in", NULL, "incomming messages" },
	{ DBG_MSG_OUT,		"msg_out", NULL, "outgoing messages" },
	{ DBG_MSG_DMP_IN,	"msg_dmp_in", NULL, "hex-dump incomming messages" },
	{ DBG_MSG_DMP_OUT,	"msg_dmp_out", NULL,"hex-dump of outgong messages"  },
	

	{ DBG_ELEM_IN,  	"elem_in", NULL, "elements of incomming messages"},
	{ DBG_ELEM_OUT, 	"elem_out", NULL, "elements of outgoing messages"},
	{ DBG_ELEM_DETAIL_IN, 	"elem_detail_in", NULL, "details of incomming message elements" },
	{ DBG_ELEM_DETAIL_OUT, 	"elem_detail_out",NULL, "details of outgoing message elememnts" },
	{ DBG_ELEM_DMP_IN, 	"elem_dmp_in", NULL, "hex-dump of incoming elements"},
	{ DBG_ELEM_DMP_OUT, 	"elem_dmp_out", NULL, "hex-dump of outgoing elements"},
	{ DBG_ELEM_VNDR,	"elem_vndr", NULL, "expand vendor specific payloads"},	
	
	{ DBG_DTLS, 		"dtls",NULL, "DTLS related stuff"},
	{ DBG_DTLS_BIO,		"dtls_bio",NULL, "DTLS BIO releated" },
	{ DBG_DTLS_BIO_DMP,	"dtls_bio_dmp",NULL, "hex-dump dtls packets" },
	{ DBG_DTLS_DETAIL, 	"dtls_detail",NULL, "DTLS detailed messages"},

	{ DBG_X,		"x", NULL, "only for developers" },

	{ DBG_ALL, 		"all", NULL, "all debug levels at once"},

	
	{ 0, NULL } 
};

/**
 *@}
 */







static struct cw_StrListElem theme0[] = {
	{DBG_PKT_IN, ANSI_YELLOW},
	{DBG_PKT_OUT, ANSI_YELLOW ANSI_ITALIC},
	
	{DBG_PKT_DMP_IN, ANSI_BYELLOW},
	{DBG_PKT_DMP_OUT, ANSI_BYELLOW ANSI_ITALIC},
	
	{DBG_MSG_IN, ANSI_BLUE ANSI_BOLD},
	
	{DBG_MSG_OUT, ANSI_BLUE ANSI_BOLD ANSI_ITALIC},
	{DBG_MSG_COMPOSE, ANSI_BLUE ANSI_ITALIC},
	
	
	{DBG_MSG_DMP_IN, ANSI_BBLUE },
	{DBG_MSG_DMP_OUT, ANSI_BBLUE ANSI_ITALIC},
	
	{DBG_ELEM_IN, ANSI_DEFAULT},
	{DBG_ELEM_OUT, ANSI_DEFAULT ANSI_ITALIC},
	
	{DBG_MSG_ERR, ANSI_RED},
	{DBG_PKT_ERR, ANSI_RED},
	{DBG_ELEM_ERR, ANSI_RED},
	
//	{DBG_SUBELEM, ANSI_BBLACK},
	{DBG_DTLS, ANSI_MAGENTA ANSI_BOLD},
	{DBG_DTLS_DETAIL, ANSI_MAGENTA},
	{DBG_DTLS_BIO, ANSI_BMAGENTA},

	{DBG_INFO, ANSI_DEFAULT},

	{DBG_STATE, ANSI_GREEN ANSI_BOLD},

	{DBG_RFC, ANSI_BRED},
	{DBG_X, "\x1b[31m"},
	{DBG_WARN, ANSI_CYAN},
	{DBG_MOD_DETAIL, ANSI_WHITE},
	{DBG_MOD, ANSI_BBLACK ANSI_BOLD },
//	{DBG_CFG_DMP, ANSI_BCYAN }, 
	{DBG_CFG_UPDATES,ANSI_GREEN},	

	{CW_STR_STOP, ""}
};

static struct cw_StrListElem * color_on = theme0;


struct cw_StrListElem color_ontext[] = {

/*	{DBG_ELEM_DMP, "\x1b[37m"},*/
	{DBG_ELEM_DMP_OUT, ANSI_BBLACK ANSI_ITALIC},
	{DBG_ELEM_DMP_IN,  ANSI_BBLACK},

	{CW_STR_STOP, ""}
};

/*
static struct cw_StrListElem color_off[] = {

	{CW_STR_STOP, "\x1b[22;39m\x1b[23m"}
};
*/

static struct cw_StrListElem prefix[] = {
	{DBG_INFO, 		"Info - "},
	{DBG_PKT_IN, 		"Pkt In  - "},
	{DBG_PKT_OUT, 		"Pkt Out - "},
	{DBG_MSG_IN, 		"Msg In  - "},
	{DBG_MSG_OUT,		"Msg Out - "},

	{DBG_ELEM_IN, 		"  Msg Element - "},
	{DBG_ELEM_OUT,		"  Msg Element - "},
	
	{DBG_MSG_ERR, 		"  Msg Error - "},
	{DBG_PKT_ERR, 		"  Pkt Error - "},
	{DBG_ELEM_ERR, 		"  Elem Error - "},
	{DBG_RFC, 		"  RFC - "},
	{DBG_DTLS, 		"DTLS - "},
	{DBG_DTLS_DETAIL,	 "DTLS - "},
	{DBG_WARN,	 	"Warning - "},
	{DBG_MOD, 		"Mod - "},
	{DBG_MOD_DETAIL,	"Mod - "},
	{DBG_STATE, 		"STATEMACHINE - "},
	{DBG_CFG_UPDATES,	"Cfg - "},



	{DBG_X, "XXXXX - "},


	{CW_STR_STOP, ""}
};

static const char *get_dbg_color_on(int level)
{
	if (!(cw_dbg_opt_display & DBG_DISP_COLORS))
		return "";
	return cw_strlist_get_str(color_on, level);
}

/*
static const char *get_dbg_color_off(int level)
{
	if (!(cw_dbg_opt_display & DBG_DISP_COLORS))
		return "";
	return cw_strlist_get_str(color_off, level);
}
*/

static const char *get_dbg_prefix(int level)
{
	return cw_strlist_get_str(prefix, level);
}

const char *get_dbg_color_ontext(int level)
{
	if (!(cw_dbg_opt_display & DBG_DISP_COLORS))
		return "";
	return cw_strlist_get_str(color_ontext, level);

}


/**
 * Check if a specific debug level is set.
 * @param level Level to check
 * @return 0 if leveln is not set, otherwise level is set
 */

int cw_dbg_is_level(int level)
{
	if (cw_dbg_opt_level == NULL)
		return 0;

	return mavl_get(cw_dbg_opt_level,&level) == NULL ? 0:1;


//	if (level > 1 && (level &1))
		return 1;

/*	if (level >= DBG_ALL ){
		return 1;
	}*/
//	return (cw_dbg_opt_level & (level));
}


static void cw_dbg_vlog_line(struct cw_LogWriter * writer, 
		const char * prefix, const char * prefix_color,
		const char *textcolor,const char * format, va_list args)
{
	char fbuf[512];

	if ( writer->colored){
		sprintf(fbuf,"DBG: %s%s%s%s%s",
			prefix_color,prefix,textcolor,format,DBG_CLR_OFF);
	}
	else{
		sprintf(fbuf,"DBG: %s%s",
			prefix,format);
				
	}
	writer->write(LOG_DEBUG,fbuf,args,writer);

}



/**
 * Put a list of missing mandatory message elements to debug output
 */
void cw_dbg_missing_mand(int level, struct cw_Conn *conn, int ** ml, int n,
			 int  * a)
{
	/*
//      if (!cw_dbg_is_level(DBG_MSG_ERR) || n == 0)
//              return;
*/


	char buffer[2000];
/*	char *p = buffer; */
	int i;
/*	char *delim = "";*/
	
	if (!cw_dbg_is_level(level) || n == 0)
		return;
	
/*
	// TODO XXXX
*/
	for (i = 0; i < n; i++) {
/*		p += sprintf(p, "%s", delim);
		delim = ", ";
		p += sprintf(p, "%s", cw_strelemp(conn->actions, ml[i]->elem_id));
*/
	}
	cw_dbg(level, "Missing mandatory elements: [%s]", buffer);
}




/**
 * Display a packet on for debugger
 */
void cw_dbg_pkt(int level, struct cw_Conn *conn, uint8_t * packet, int len,
		struct sockaddr *from)
{

	char buf[1024];
	int (*fmt_pkt_hdr)(char *dst, int incomming, uint8_t * packet, int len,
		      struct sockaddr *from);
	fmt_pkt_hdr = NULL;
	if (conn){
		if (conn->msgset)
			fmt_pkt_hdr = conn->msgset->format_pkt_hdr;
	}
	if (fmt_pkt_hdr==NULL){
		fmt_pkt_hdr = cw_format_pkt_hdr;
	}


	if (!cw_dbg_is_level(level))
		return;
	
	if (level == DBG_PKT_IN)
		fmt_pkt_hdr(buf, 1,  packet, len, from);
	else
		fmt_pkt_hdr(buf, 0,  packet, len, from);
		
/*	hlen = cw_get_hdr_msg_offset(packet);*/

	cw_dbg(level, "%s", buf);
		
//	if (cw_dbg_is_level(DBG_PKT_DMP)) {
		int dlevel;
		if (level == DBG_PKT_IN){
			dlevel=DBG_PKT_DMP_IN;
		}
		else{
			dlevel=DBG_PKT_DMP_OUT;
		}
		cw_dbg_dmp(dlevel,packet,len,"");
//	} 

}


void cw_dbg_dmp(int level, const uint8_t * data, int len, const char *format, ...)
{
	char *dmp,*s,*c;
	struct cw_FormatDumpSettings settings;

	if (!cw_dbg_is_level(level))
		return;

	cw_format_get_dump_defaults(&settings);
	
	settings.dump_prefix="  ";
	settings.newline="\n  ";
	settings.dump_suffix="\n";
		

	dmp = cw_format_dump(data, len, &settings);

	/* wrtie the dump line by line to the log file */
	c=dmp;
	while ((s=strchr(c,'\n'))!=NULL){
		*s=0;
		cw_dbg(level," %s",c);
		c=s+1;
	}

	free(dmp);
}


void cw_dbg_msg(int level, struct cw_Conn *conn, uint8_t * packet, int len,
		struct sockaddr *from)
{

	char sock_buf[SOCK_ADDR_BUFSIZE];
	char buf[1024];
	char *s;
	struct cw_MsgData search;
	struct cw_MsgData * message;
	const char * msname;	
	uint8_t *msgptr;
	int msg_id;
	
	if (!cw_dbg_is_level(level))
		return;	
	
	s = buf;

	msgptr = cw_get_hdr_msg_ptr(packet);
	msg_id = cw_get_msg_id(msgptr);

	search.type = msg_id;
	message = mavl_get(conn->msgset->msgdata,&search);

	if (!message)
		msname=cw_strmsg(msg_id);
	else
		msname = message->name;
	
	s += sprintf(s, "%s Message (type=%d) ", msname  , msg_id);
	if (level == DBG_MSG_IN)
		s += sprintf(s, "from %s ", sock_addr2str(from,sock_buf));
	else
		s += sprintf(s, "to %s ", sock_addr2str(from,sock_buf));

	s += sprintf(s, ", Seqnum: %d ElemLen: %d", cw_get_msg_seqnum(msgptr),
		     cw_get_msg_elems_len(msgptr));

	cw_dbg(level, "%s", buf);
	
	
//	if (cw_dbg_is_level(DBG_MSG_DMP)){
		int dlevel;
		if(level==DBG_MSG_IN){
			dlevel = DBG_MSG_DMP_IN;
		}
		else{
			dlevel = DBG_MSG_DMP_OUT;
		}
		cw_dbg_dmp(dlevel,packet,len,"");
//	}
	

}


void cw_dbg(int level, const char *format, ...){
	int i;
	va_list args;
	
	if (!(cw_dbg_is_level(level)))
		return;
	
	for (i=0; cw_log_writers[i]; i++){
		va_start(args, format);
		cw_dbg_vlog_line(cw_log_writers[i],
			get_dbg_prefix(level),get_dbg_color_on(level),
			get_dbg_color_ontext(level),
			format, args);
		va_end(args);
	}
}



void cw_dbg_elem(int level, struct cw_Conn *conn, int msg, 
	struct cw_ElemHandler * handler, const uint8_t * msgbuf, int len)
{
	char vendorname[256];
	char vendor_details[265];

	
	if (!cw_dbg_is_level(level))
		return;
		
	*vendor_details = 0;

	if (handler->vendor){
		sprintf(vendorname,"Vendor %s",cw_strvendor(handler->vendor));
	}
	else{
		sprintf(vendorname,"%s","");
	}


	cw_dbg(level,"%s %d (%s), len=%d ",vendorname,handler->id,
			handler->name,len);
	
	if (cw_dbg_is_level(DBG_ELEM_DMP_OUT) || cw_dbg_is_level(DBG_ELEM_DMP_IN)) {
		if (level == DBG_ELEM_OUT)
			cw_dbg_dmp(DBG_ELEM_DMP_OUT,msgbuf,len,"");
		else 
			cw_dbg_dmp(DBG_ELEM_DMP_IN,msgbuf,len,"");

	}

	return;

}



/**
  * Set debug level
  * @param level debug level to set, allowed values are enumberated in #cw_dbg_levels structure.
  * @param on 1: turns the specified debug level on, 0: turns the specified debug level off.
  */

void cw_dbg_set_level (int level, int on)
{
	int exists;

	if (cw_dbg_opt_level == NULL){
		cw_dbg_opt_level = mavl_create(dbg_cmp,NULL,sizeof(int));
		if (cw_dbg_opt_level == NULL)
			return;
	}

	if (on){
		mavl_insert(cw_dbg_opt_level,&level,&exists);
	}
	else 
		mavl_del(cw_dbg_opt_level,&level);


/*
	switch (level) {
		case DBG_ALL:
			if (on)
				cw_dbg_opt_level = 0xffffffff;
			else
				cw_dbg_opt_level = 0;
			break;
		default:
			if (on)
				cw_dbg_opt_level |= (level);
			else 
				cw_dbg_opt_level &= (0xffffffff) ^ (level);
	}
	*/
}


int cw_dbg_set_level_from_str0(const char *level,int on)
{
	int i,all;
	all = strcmp(level,"all")==0 ? 1: 0;
	
	for(i=0; cw_dbg_strings[i].str != NULL; i++){
		if (strcmp(cw_dbg_strings[i].str,level)==0 || all){
			if (cw_dbg_strings[i].str_list==NULL)
				cw_dbg_set_level(cw_dbg_strings[i].level,on);
			else {
				const char **l;
				for (l=cw_dbg_strings[i].str_list; *l; l++){
					if (!cw_dbg_set_level_from_str0(*l,on)){
						stop();
					}
				}
			}
			if (!all)
				return 1;
		}
	}	
	if (all)
		return 1;
/*	blevel = cw_strlist_get_id(cw_dbg_strings, slevel);
	if (blevel==-1)
		return 0;
*/		
//	cw_dbg_set_level(blevel,on);
//	return 1;
	return 0;
}


int cw_dbg_set_level_from_str(const char *level)
{
	int on;
	const char *slevel;
	
	switch(*level){
		case '-':
		case '!':
		case '~':
			on =0;
			slevel=level+1;
			break;
		case '+':
			slevel=level+1;
			on=1;
			break;
		default:
			slevel=level;
			on=1;
	}
	return cw_dbg_set_level_from_str0(slevel,on);
}




void cw_dbg_print_help(FILE *out, const char * prefix)
{
	struct cw_DbgStr *s;
	for (s=cw_dbg_strings; s->str != NULL; s++){
		const char * descr = s->descr!=NULL ? s->descr : "";
		fprintf(out,"%s%s: %s",prefix,s->str,descr);
		if (s->str_list != NULL){
			const char **l;
			char *sp="";
			fprintf(out," (");
			for(l = s->str_list; *l!=NULL; l++){
				fprintf(out,"%s%s",sp,*l);
				sp=" ";
			}
			fprintf(out,")");
		}
		fprintf(out,"\n");
	}
}



void cw_dbg_dot11_elems(const uint8_t *src,int len)
{
	uint8_t id,l;
	int p;
	char str[1024];

	for(p=0; p<len; p+=l+2){
		if (len-p<3){
			cw_dbg(DBG_X,"Error in dot11 element");
			return;
		}
		id=src[p];
		l=src[p+1];
		cw_format_dot11_elem(str,id,src+p+2,l);
		cw_dbg_dmp(DBG_X,src+p+2,l,"");
		cw_dbg(DBG_X,str);
	}

}

void cw_dbg_dot11_frame(uint8_t * frame,int len)
{
	char hdr[1024];
	cw_format_dot11_hdr(hdr, frame, len);
	cw_dbg(DBG_X,"%s",hdr);

	int type =dot11_get_type_and_subtype(frame);

	switch (type){
		case DOT11_ASSOC_REQ:
			cw_dbg_dot11_elems(frame+28,len-28);
			break;
		case DOT11_ASSOC_RESP:
			cw_dbg(DBG_X,"  Capapility info: %04X",dot11_assoc_resp_get_cap(frame)); 
			cw_dbg(DBG_X,"  Status CodeCapapility info: %04X",dot11_assoc_resp_get_status_code(frame));
			cw_dbg(DBG_X,"  Assoc ID: %04X",dot11_assoc_resp_get_assoc_id(frame)); 

			cw_dbg_dot11_elems((frame+DOT11_BODY_POS+DOT11_ASSOC_RESP_BODY_LEN),
					len-DOT11_BODY_POS-DOT11_ASSOC_RESP_BODY_LEN);
			break;
			
	}
}


/**@}*/


/**@}*/