#ifndef __TOOLS_T_C_H__
#define __TOOLS_T_C_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <time.h>

#include <sys/ioctl.h>


// to define DEBUG in gcc cli do: gcc -D DEBUG=1 or 0 if need!
#ifndef DEBUG
  #define DEBUG 0
#endif


// F_OUT file (stream) to log
#ifndef F_OUT
  #define F_OUT stdout
#endif
// F_ERR file (stream) to log
#ifndef F_ERR
  #define F_ERR stderr
#endif

/*
#ifndef SECOND
  #define SECOND 0
#endif
#ifndef NANOSECOND
  #define NANOSECOND 0
#endif

double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
*/

#if 1

extern long int PRECISION_TYPE_FLOAT ;
extern long int PRECISION_TYPE_DOUBLE ;
extern long int PRECISION_TYPE_L_DOUBLE ;

#endif


//void get_cursor_position(int *col, int *rows);

#if DEBUG

#define debug_print(fmt, ...) \
  do { /*if (DEBUG)*/ fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
      __LINE__, __func__, __VA_ARGS__); } while (0)

#define PRINT_DEBUG_(fmt, ...) \
  do { /*if (DEBUG)*/ fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
      __LINE__, __func__, __VA_ARGS__); } while (0)

#else
#define debug_print(fmt, ...) {} 

#define PRINT_DEBUG_(fmt, ...) {}

#endif

#define error_print(fmt, ...) \
   fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
      __LINE__, __func__, __VA_ARGS__); 

#define PRINT_ERROR(fmt, ...) \
   fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
      __LINE__, __func__, __VA_ARGS__); 

#define PRINT_LOC_T(fmt, ...) \
   fprintf(F_OUT, "%s:%d:%s(): " fmt, __FILE__, \
      __LINE__, __func__, __VA_ARGS__); 



#define TYPE_CHAR char
#define TYPE_U_CHAR unsigned char
#define TYPE_INT int
#define TYPE_U_INT unsigned int
#define TYPE_L_INT long int
#define TYPE_U_L_INT unsigned long int
#define TYPE_SIZE_T size_t
#define TYPE_FLOAT float
#define TYPE_DOUBLE double
#define TYPE_L_DOUBLE long double
#define TYPE_STRING char*

#define FREE(x)  { free((x)); (x) = NULL;} 

#define FOREACH(array, size, function)\
  for(size_t _ind = 0; _ind < size; ++_ind) function(array[_ind]);

#define MIN(X, Y) (((Y) < (X)) ? (Y) : (X))
#define MAX(X, Y) (((Y) > (X)) ? (Y) : (X))

#define GENERATE_ALL(type)\
  int COMPARE_N_##type(const void *,const    void*);\
  void COPY_ARRAY_##type(type* dst, const type* src, size_t size);\
  type MAX_ARRAY_##type(const  type *array, size_t size);\
  size_t ARG_MAX_ARRAY_##type(const type *array, size_t size);\
  type MIN_ARRAY_##type(const  type *array, size_t size);\
  size_t ARG_MIN_ARRAY_##type(const  type *array, size_t size);\
  TYPE_STRING type##_TO_STR(type var);\
  

GENERATE_ALL(TYPE_CHAR)
GENERATE_ALL(TYPE_U_CHAR)
GENERATE_ALL(TYPE_INT)
GENERATE_ALL(TYPE_U_INT)
GENERATE_ALL(TYPE_L_INT)
GENERATE_ALL(TYPE_U_L_INT)
GENERATE_ALL(TYPE_SIZE_T)
GENERATE_ALL(TYPE_FLOAT)
GENERATE_ALL(TYPE_DOUBLE)
GENERATE_ALL(TYPE_L_DOUBLE)
GENERATE_ALL(TYPE_STRING)

/* strto_type */

int strto_TYPE_INT(char *str, char **endptr);
unsigned int strto_TYPE_U_INT(char *str, char **endptr);
long int strto_TYPE_L_INT(char *str, char **endptr);
unsigned long int strto_TYPE_U_L_INT(char *str, char **endptr);
size_t strto_TYPE_SIZE_T(char *str, char **endptr);
float strto_TYPE_FLOAT(char *str, char **endptr);
double strto_TYPE_DOUBLE(char *str, char **endptr);
long double strto_TYPE_L_DOUBLE(char *str, char **endptr);

/*
 * time calucl
 */
double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);

double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);

long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);


#endif /*__TOOLS_T_C_H__*/



#ifndef __BAR_PROGRESS_H__
#define __BAR_PROGRESS_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <unistd.h>
#include <signal.h>
#include <sys/ioctl.h>



/*
 * Prepares screen for progress bar.
 */
void bar_progress_start(void);

void bar_progress_step_msg(int step_progress, int all_progress, char *msg, char fill_bar, char fill_dot, int colored);

/*
 * progress  value 0 to 100
 */
void bar_progress_step(float step_percent);

/*
 * Removes progress bar and restores original screen size.
 */
void bar_progress_stop(void);

#define bg_red "\033[0;41m"
#define bg_green "\033[0;42m"
#define bg_yellow "\033[0;43m"
#define bg_blue "\033[0;44m"
#define bg_magenta "\033[0;45m"
#define bg_cyan "\033[0;46m"
#define bg_white "\033[30;47m"
#define bg_gray "\033[37;40m"

#define BG_GREEN "\033[42;30m"
#define BG_RED "\033[41m"



#endif /* __BAR_PROGRESS_H */








/* implementations */

/*  IMPLEMENTATION_TOOLS */


#define POW 17
#define MMOD ((1 << (POW)) - 1)
#define SUBA 5
#define SUBB 8

#define GEN_TO_STR_N(type,size,format)  \
  TYPE_STRING type##_TO_STR(type var){  \
    char *ret = malloc(size);                     \
    /*int szret = */sprintf(ret,format,var);            \
    /*ret[szret]='\0'*//*no need , already by default */;              \
    return ret;                         \
  }\


#define GENERATE_FUNCTION_ALL(type)\
  type MAX_ARRAY_##type(const type *array, size_t size){\
    if(array == NULL) return 0;\
    type mx =(type)array[0];\
    for(size_t i = 0; i < size; ++i)\
      if(COMPARE_N_##type(&mx,&array[i]) < 0) mx =(type)array[i];\
    return mx;}\
\
  size_t ARG_MAX_ARRAY_##type(const type *array, size_t size){\
    if(array == NULL) return 0;\
    size_t i_mx = 0;\
    for(size_t i = 0; i < size; ++i)\
      if(COMPARE_N_##type(&array[i_mx],&array[i]) < 0) i_mx = i;\
    return i_mx;}\
\
  type MIN_ARRAY_##type(const type *array, size_t size){\
    if(array == NULL) return 0;\
    type mn =(type)array[0];\
    for(size_t i = 0; i < size; ++i)\
      if(COMPARE_N_##type(&mn,&array[i]) > 0) mn =(type)array[i];\
    return mn;}\
\
  size_t ARG_MIN_ARRAY_##type(const type *array, size_t size){\
    if(array == NULL) return 0;\
    size_t i_mn = 0;\
    for(size_t i = 0; i < size; ++i)\
      if(COMPARE_N_##type(&array[i_mn],&array[i]) > 0) i_mn = i;\
    return i_mn;}\
\



#define GENERATE_FUNCTION_NUMERIC(type)\
  int COMPARE_N_##type(const void *a, const  void *b){              \
    type diff = 0;\
     if((*(type*)a > *(type*)b)){           \
      diff =(*(type*)a - *(type*)b) * PRECISION_##type;           \
    /*char *str_diff = type##_TO_STR(diff), *str_a = type##_TO_STR(*(type*)a), *str_b = type##_TO_STR(*(type*)b);\
    PRINT_DEBUG_(" diff = %s a=%s b=%s PRECISION : %ld\n",str_diff, str_a, str_b, PRECISION_##type);\
    free(str_diff); free(str_a); free(str_b);\
     */ \
      if(diff >= 1) return 1;\
      return 0;\
     }else{\
      diff =(*(type*)b - *(type*)a) * PRECISION_##type;           \
    /*char *str_diff = type##_TO_STR(diff), *str_a = type##_TO_STR(*(type*)a), *str_b = type##_TO_STR(*(type*)b);\
    PRINT_DEBUG_(" diff = %s a=%s b=%s PRECISION : %ld\n",str_diff, str_a, str_b, PRECISION_##type);\
    free(str_diff); free(str_a); free(str_b);\
    */\
      if(diff >= 1) return -1;\
      return 0;\
     }\
    \
    /*if (diff <= -1) return -1;                                                    \
    if (diff >= 1) return 1;                                                    \
    return 0;                                                    \
  */\
  }                                                                 \
                                                                    \
  void COPY_ARRAY_##type(type *dst, const type *src, size_t size){  \
    for(size_t i = 0; i < size; ++i) dst[i]=src[i];                 \
  }                                                                 \
\




#define IMPLEMENTATION_TOOLS()\
\
GEN_TO_STR_N(TYPE_CHAR,2,"%c")\
GEN_TO_STR_N(TYPE_U_CHAR,2,"%c")\
GEN_TO_STR_N(TYPE_INT,22,"%d")\
GEN_TO_STR_N(TYPE_U_INT,22,"%u")\
GEN_TO_STR_N(TYPE_L_INT,22,"%ld")\
GEN_TO_STR_N(TYPE_U_L_INT,22,"%lu")\
GEN_TO_STR_N(TYPE_SIZE_T,22,"%lu")\
GEN_TO_STR_N(TYPE_FLOAT,128,"%.10f")\
GEN_TO_STR_N(TYPE_DOUBLE,256,"%.30lf")\
GEN_TO_STR_N(TYPE_L_DOUBLE,256,"%.30Lf")\
\
TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){\
  return var;\
}\
\
\
long int PRECISION_TYPE_CHAR  = 1;\
long int PRECISION_TYPE_U_CHAR  = 1;\
long int PRECISION_TYPE_INT  = 1;\
long int PRECISION_TYPE_U_INT  = 1;\
long int PRECISION_TYPE_L_INT  = 1;\
long int PRECISION_TYPE_U_L_INT  = 1;\
long int PRECISION_TYPE_SIZE_T  = 1;\
\
long int PRECISION_TYPE_FLOAT  = 100000000;\
long int PRECISION_TYPE_DOUBLE  = 100000000000;\
long int PRECISION_TYPE_L_DOUBLE  = 100000000000000;\
\
\
\
\
int \
COMPARE_N_TYPE_STRING(const void *a,const  void* b)\
{\
  char **aa=(char**)a;\
  char **bb=(char**)b;\
  PRINT_DEBUG_("a=%s, b=%s\n",*aa, *bb);\
  return strcmp(*aa,*bb);\
}\
\
void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size)\
{\
  for(size_t i = 0; i < size; ++i) strcpy(dst[i],src[i]);\
}\
\
\
GENERATE_FUNCTION_NUMERIC(TYPE_CHAR)\
GENERATE_FUNCTION_NUMERIC(TYPE_U_CHAR)\
GENERATE_FUNCTION_NUMERIC(TYPE_INT)\
GENERATE_FUNCTION_NUMERIC(TYPE_U_INT)\
GENERATE_FUNCTION_NUMERIC(TYPE_L_INT)\
GENERATE_FUNCTION_NUMERIC(TYPE_U_L_INT)\
GENERATE_FUNCTION_NUMERIC(TYPE_SIZE_T)\
GENERATE_FUNCTION_NUMERIC(TYPE_FLOAT)\
GENERATE_FUNCTION_NUMERIC(TYPE_DOUBLE)\
GENERATE_FUNCTION_NUMERIC(TYPE_L_DOUBLE)\
\
GENERATE_FUNCTION_ALL(TYPE_CHAR)\
GENERATE_FUNCTION_ALL(TYPE_U_CHAR)\
GENERATE_FUNCTION_ALL(TYPE_INT)\
GENERATE_FUNCTION_ALL(TYPE_U_INT)\
GENERATE_FUNCTION_ALL(TYPE_L_INT)\
GENERATE_FUNCTION_ALL(TYPE_U_L_INT)\
GENERATE_FUNCTION_ALL(TYPE_SIZE_T)\
GENERATE_FUNCTION_ALL(TYPE_FLOAT)\
GENERATE_FUNCTION_ALL(TYPE_DOUBLE)\
GENERATE_FUNCTION_ALL(TYPE_L_DOUBLE)\
GENERATE_FUNCTION_ALL(TYPE_STRING)\
\
/* strto_type */\
  \
int strto_TYPE_INT(char *str, char **endptr){ \
  return (int)strtol(str,endptr,10);\
}\
unsigned int strto_TYPE_U_INT(char *str, char **endptr){ \
  return (unsigned int)strtoul(str,endptr,10);\
}\
long int strto_TYPE_L_INT(char *str, char **endptr){\
  return strtol(str,endptr,10);\
}\
unsigned long int strto_TYPE_U_L_INT(char *str, char **endptr){\
  return strtoul(str,endptr,10);\
}\
size_t strto_TYPE_SIZE_T(char *str, char **endptr){\
  return strtoul(str,endptr,10);\
}\
float strto_TYPE_FLOAT(char *str, char **endptr){\
  return strtof(str,endptr);\
}\
double strto_TYPE_DOUBLE(char *str, char **endptr){\
  return strtod(str,endptr);\
}\
long double strto_TYPE_L_DOUBLE(char *str, char **endptr){\
  return strtold(str,endptr);\
}\
\
\
/*\
 * time section\
 */\
\
double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start){\
  /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n",  time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
  return (time_stop.tv_sec - time_start.tv_sec) + 1.0e-9 * (time_stop.tv_nsec - time_start.tv_nsec);\
}\
\
double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start){\
  /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n",  time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
  return 1.0e3 * (time_stop.tv_sec - time_start.tv_sec) + 1.0e-6 * (time_stop.tv_nsec - time_start.tv_nsec);\
}\
\
long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start){\
  /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n",  time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
  return 1.0e9 * (time_stop.tv_sec - time_start.tv_sec) + (time_stop.tv_nsec - time_start.tv_nsec);\
}\
\




#define IMPLEMENTATION_PROGRESS_BAR()\
\
static struct winsize w;\
static int initialized = 0;\
\
\
static void set_window_height_for_bar_progress(int height)\
{\
	fprintf(stdout, "\n\0337"		/* save cursor*/\
			"\033[0;%dr"		/* set scroll region (this will place the cursor in the top left)*/\
			"\0338\033[1A\033[J"	/* restore cursor but ensure its inside the scrolling area*/\
			, height);\
	fflush(stdout);\
}\
\
\
static void init_progress_bar()\
{\
	/*ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);*/\
	ioctl(1, TIOCGWINSZ, &w);\
	set_window_height_for_bar_progress(w.ws_row - 1);\
}\
\
\
static void abort_progress_bar()\
{\
	bar_progress_stop();\
	exit(0);\
}\
\
\
void bar_progress_start()\
{\
	signal(SIGWINCH, init_progress_bar);\
	signal(SIGINT, abort_progress_bar);\
	/*signal(SIGSEGV, abort_progress_bar);*/\
	init_progress_bar();\
	initialized = 1;\
	bar_progress_step(0);\
}\
\
\
void bar_progress_step_msg(int step_progress, int all_progress, char *msg, char fill_bar, char fill_dot, int colored /*bool */)\
{\
  static int cur_round=0;\
  char prgss[]="\\|/-";\
  int len = strlen(prgss);\
\
	if (initialized == 0) {\
		fprintf(stderr, "error: bar_progress_step() called before bar_progress_start().\n");\
		exit(1);\
	}\
\
	if (step_progress < 0) {\
		step_progress = 0;\
	} \
  else if (step_progress >= all_progress) {\
		step_progress = all_progress -1;\
	}\
  int size_char_log= strlen(msg) + strlen("(-) Progress: [100a] [aaaa/bbbb] a");\
	int width = (w.ws_col - size_char_log);\
  /*int j;*/\
  /*\
  for(int j=0; j< width ; ++j)\
    if (j<(int)(width * (step_progress / 100))) bar[j]='=';\
    else bar[j]='.';\
	bar[width] = 0;\
  */\
  int status_percent =  (step_progress+1) * 100 / all_progress;\
  int status_progress = (step_progress+1) * width / all_progress;\
\
	char *bar = malloc(status_progress + 1);  /*w.ws_col);*/\
	char *dot = malloc(width - status_progress +1 ); /*w.ws_col);*/\
\
  memset(bar,fill_bar,status_progress); \
\
  bar[status_progress]='\0';\
\
  memset(dot,fill_dot, width-status_progress);\
  dot[width - status_progress]='\0'; \
   \
\
	if(colored)printf("\e[s\e[%d;0H(%c) "bg_white"Progress: [%3d%%]\e[0m ["bg_green"%s"bg_red"%s\e[0m] %s [%3d/%3d]\e[u", w.ws_row + 1, prgss[cur_round], status_percent, bar, dot, msg, step_progress + 1, all_progress);\
  else printf("\e[s\e[%d;0H(%c) "bg_gray"Progress: [%3d%%]\e[0m ["bg_white"%s"bg_gray"%s\e[0m] %s [%3d/%3d]\e[u", w.ws_row + 1, prgss[cur_round], status_percent, bar, dot, msg, step_progress + 1, all_progress);\
	/*fprintf(stdout, "\e[s\e[%d;0H(%c) "bg_green"Progress: [%3d%%]\e[0m ["bg_green"%s"bg_red"%s\e[0m] %s [%3d/%3d]\e[u", w.ws_row + 1,prgss[cur_round], status_percent, bar,dot,msg,step_progress,all_progress);*/\
	/*fprintf(stdout, "\e[s\e[%d;0H(%c) "bg_green"Progress: [%3d%%]\e[0m ["BG_GREEN"%s"BG_RED"%s\e[0m] %s [%3d/%3d]\e[u", w.ws_row + 1,prgss[cur_round], status_percent, bar,dot,msg,step_progress,all_progress);*/\
	/*fprintf(stdout, "\e[s\e[%d;0H(%c) \e[42;30mProgress: [%3d%%]\e[0m [%s%s%s%s\033[0m] %s [%3d/%3d]\e[u", w.ws_row + 1,prgss[cur_round], status_percent,BG_GREEN, bar, BG_RED,dot,msg,step_progress,all_progress);*/\
	/*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [\033[42;30m%s\033[41m%s\033[0m]\e[u", w.ws_row + 1, (int) step_progress, bar,dot);*/\
	/*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [%s]\e[u", w.ws_row + 1, (int) step_progress, bar);*/\
	/*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [%s%s]\e[u", w.ws_row + 1, (int) step_progress, bar,dot);*/\
	\
  fflush(stdout);\
\
  if(cur_round<len-1) ++cur_round;\
  else cur_round = 0;\
\
	free(bar);\
	free(dot);\
}\
\
void bar_progress_step(float step_progress)\
{\
	if (initialized == 0) {\
		fprintf(stderr, "error: bar_progress_step() called before bar_progress_start().\n");\
		exit(1);\
	}\
	char *bar = malloc(w.ws_col);\
	char *dot = malloc(w.ws_col);\
\
	if (step_progress < 0) {\
		step_progress = 0;\
	} else if (step_progress > 100) {\
		step_progress = 100;\
	}\
	int width = (w.ws_col - 20);\
  int j;\
  /*\
  for(int j=0; j< width ; ++j)\
    if (j<(int)(width * (step_progress / 100))) bar[j]='=';\
    else bar[j]='.';\
	bar[width] = 0;\
  */\
  int status = (int)(width * (step_progress / 100));\
  for(j=0; j< status ; ++j)\
    bar[j]='=';\
    \
  bar[j]='\0';\
  for(j=0;j<width-status; ++j)\
     dot[j]='.';\
  dot[j]='\0'; \
   \
\
	fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [%s%s%s%s\033[0m]\e[u", w.ws_row + 1, (int) step_progress,BG_GREEN, bar, BG_RED,dot);\
	/*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [\033[42;30m%s\033[41m%s\033[0m]\e[u", w.ws_row + 1, (int) step_progress, bar,dot);*/\
	/*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [%s]\e[u", w.ws_row + 1, (int) step_progress, bar);*/\
	/*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [%s%s]\e[u", w.ws_row + 1, (int) step_progress, bar,dot);*/\
	\
  fflush(stdout);\
\
	free(bar);\
	free(dot);\
}\
\
\
void bar_progress_stop()\
{\
	set_window_height_for_bar_progress(w.ws_row);\
}\

;