#define	_CRT_SECURE_NO_WARNINGS

#if defined(WIN32)

/* Include Windows specific headers here.
 */
#include <windows.h>

#else

/* Include Unix specific headers here.
 */

#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "dpcdecl.h" 
#include "depp.h"
#include "dmgr.h"

#include <gtk/gtk.h>
#include <cv.h>
#include <cxcore.h>
#include <highgui.h>

/* ------------------------------------------------------------ */
/*	Local Type and Constant Definitions                     */
/* ------------------------------------------------------------ */

const int cchSzLen = 1024;
const int cbBlockSize = 1000;

/* ------------------------------------------------------------ */
/*		Global Variables                                */
/* ------------------------------------------------------------ */

char			szAction[cchSzLen];
const char*	        szRegister="10";
char                    szDvc[]="Nexys3";
char			szFile[cchSzLen];
char			szCount[cchSzLen];
const char*	        szByte;

HIF			hif = hifInvalid;

FILE *			fhin = NULL;
FILE *			fhout = NULL;

/* ------------------------------------------------------------ */
/*				Global GTK Variables            */
/* ------------------------------------------------------------ */

/* ------------------------------------------------------------ */
/*					Forward Declarations    */
/* ------------------------------------------------------------ */

BOOL		FInit();
void		ErrorExit();
void		DoPutReg(char* char_signal);
char*    	DoGetReg();
char*		get_binary(int n);
void		StrcpyS( char* szDst, size_t cchDst, const char* szSrc );
char*           find_state(char* output);

/*********** FPGA variables ********************/

char char_clock[]="0100";
char char_reset[]="1000";
char char_zero[]="0000";
char char_light[]="0010";
char char_noise[]="0001";      

/***********************************************/   

/***********************************************/

struct S_GtkWidget {

  GtkWidget *output_text;
  GtkWidget *output;
  GtkWidget *label_state;
  GtkWidget *label_current_state;   

  GtkWidget *clock;
  GtkWidget *reset;
  GtkWidget *light;
  GtkWidget *noise;   

  GtkWidget *drawing_area;
  GtkWidget *alignment;

};   

const char* possible_state[] = { "Awake", "101",
  "Light Sleeping", "010",
  "Deep Sleeping", "000",
  "Distress", "111" };

/* ------------------------------------------------------------ */
/*				Procedure Definitions           */
/* ------------------------------------------------------------ */
/***	main
 **
 **	Synopsis
 **		int main(cszArg, rgszArg)
 **
 **	Input:
 **		cszArg		- count of command line arguments
 **		rgszArg		- array of command line arguments
 **
 **	Output:
 **		none
 **
 **	Errors:
 **		Exits with exit code 0 if successful, else non-zero
 **
 **	Description:
 **		main function of DEPP Demo application.
 */

char* find_state(char* label_output)
{ 
  int i;
  char* true_char;

  for(i=1;i<=7;i=i+2)
  { 
    if (strcmp(possible_state[i],label_output)==0)
    { true_char = (char*) possible_state[i-1];} 	  
  }

  return true_char;
}


/*********** Function of clock signal on FPGA Board ******/

int update_state (GtkWidget *widget, struct S_GtkWidget* structure) 
{ 
  char* binary_output;
  char* state_from_output;

  // value  of the register

  // DMGR API Call: DmgrOpen
  if(!DmgrOpen(&hif,szDvc)) {
    printf("DmgrOpen failed (check the device name you provided)\n");
    return 0;
  }

  // DEPP API call: DeppEnable
  if(!DeppEnable(hif)) {
    printf("DeppEnable failed\n");
    return 0;
  }

  // update output and state from output
  sleep(1);
  binary_output=DoGetReg();
  state_from_output=find_state(binary_output);	
  gtk_label_set_text(GTK_LABEL(structure->output),binary_output);	
  gtk_label_set_text(GTK_LABEL(structure->label_current_state),state_from_output);	
  DoPutReg(char_zero);

  if( hif != hifInvalid ) {
    // DEPP API Call: DeppDisable
    DeppDisable(hif);

    // DMGR API Call: DmgrClose
    DmgrClose(hif);
  }

  return 0;		
}


int input_signal (GtkWidget *widget, char* char_byte) 
{ 
  // DMGR API Call: DmgrOpen
  if(!DmgrOpen(&hif,szDvc)) {
    printf("DmgrOpen failed (check the device name you provided)\n");
    return 0;
  }

  // DEPP API call: DeppEnable
  if(!DeppEnable(hif)) {
    printf("DeppEnable failed\n");
    return 0;
  }

  // put and get byte in register szRegister

  DoPutReg(char_byte);	/* Send single byte to register */

  if( hif != hifInvalid ) {
    // DEPP API Call: DeppDisable
    DeppDisable(hif);

    // DMGR API Call: DmgrClose
    DmgrClose(hif);
  }

  return 0;    
}


int scan_binary(const char* string)
{
  int i;
  char * pEnd;
  i = strtol(string,&pEnd,2);
  return i;
}

IplImage* opencvImage;
GdkPixbuf* pix;
CvCapture* capture;

static gboolean time_handler( GtkWidget *widget ) {

  return TRUE;
}

gboolean expose_event_callback( GtkWidget      *widget,
    GdkEventExpose *event,
    gpointer        data) {
  gtk_widget_queue_draw( GTK_WIDGET( widget ));
  opencvImage = cvQueryFrame( capture );
  cvCvtColor( opencvImage, opencvImage, CV_BGR2RGB );
  pix = gdk_pixbuf_new_from_data(( guchar* )opencvImage->imageData,
      GDK_COLORSPACE_RGB,
      FALSE,
      opencvImage->depth,
      opencvImage->width,
      opencvImage->height,
      ( opencvImage->widthStep ),
      NULL, NULL);
  gdk_draw_pixbuf( widget->window,
      widget->style->fg_gc[ GTK_WIDGET_STATE( widget )],
      pix,
      0, 0, 0, 0,
      opencvImage->width,
      opencvImage->height,
      GDK_RGB_DITHER_MAX,
      0, 0);
  return TRUE;
}

/*------------------------------------------------------------- */
/*	DoGetReg                                                */
/*	Description:                                            */
/*		Gets a byte from, a specified register          */     
/*------------------------------------------------------------- */ 

char* DoGetReg() {

  BYTE	idReg;
  BYTE	idData;
  char*	szStop;
  char*	state_char;        

  idReg = (BYTE) strtol(szRegister, &szStop, 10);

  // DEPP API Call: DeppGetReg
  if(!DeppGetReg(hif, idReg, &idData, fFalse)) { 
    printf("DeppGetReg failed\n");
    ErrorExit();
  }

  state_char = get_binary(idData >> 4);			

  return state_char;
}

/* ------------------------------------------------------------ */
/*	DoPutReg                                                */ 
/*	Description:                                            */ 
/*		Sends a byte to a specified register            */
/* ------------------------------------------------------------ */

void DoPutReg(char* char_byte) {

  BYTE	idReg;
  BYTE	idData;
  char *	szStop;

  idReg = (BYTE) strtol(szRegister, &szStop, 10);

  idData= (BYTE) scan_binary(char_byte);
  // DEPP API Call: DeppPutReg
  if(!DeppPutReg(hif, idReg, idData, fFalse)) {
    printf("DeppPutReg failed\n");
    return;
  }

  printf("Complete. Register set.\n");

  return;
}

char* get_binary(int n)
{
  char* char_binary;

  char_binary = (char*) malloc(3*sizeof(char));

  sprintf(char_binary,"%d%d%d", (n >> 2 ) & 1,(n >> 1 ) & 1,(n >> 0 ) & 1);

  return char_binary; 
}


/* ------------------------------------------------------------------------------- */
/*	ErrorExit                                                                  */
/*	Description:                                                               */
/*  Disables DEPP, closes the device, close any open files, and exits the program  */
/* ------------------------------------------------------------------------------- */

void ErrorExit() {
  if( hif != hifInvalid ) {
    // DEPP API Call: DeppDisable
    DeppDisable(hif);

    // DMGR API Call: DmgrClose
    DmgrClose(hif);
  }

  if( fhin != NULL ) {
    fclose(fhin);
  }

  if( fhout != NULL ) {
    fclose(fhout);
  }

  exit(1);
}

/*------------------------------------------------------------*/
/*	StrcpyS
 **
 **	Parameters:
 **		szDst - pointer to the destination string
 **		cchDst - size of destination string
 **		szSrc - pointer to zero terminated source string
 **
 **	Return Value:
 **		none
 **
 **	Errors:
 **		none
 **
 **	Description:
 **		Cross platform version of Windows function strcpy_s.
 --------------------------------------------------------------*/


void StrcpyS( char* szDst, size_t cchDst, const char* szSrc ) {

  if ( 0 < cchDst ) {

    strncpy(szDst, szSrc, cchDst - 1);
    szDst[cchDst - 1] = '\0';
  }
}

/* Toggle callback function */

void toggle_button_callback (GtkWidget *widget, char* char_byte)
{
  if (GTK_TOGGLE_BUTTON (widget)->active) 
  {
    input_signal(widget, char_byte);        

  } else {

    input_signal(widget,char_zero); 
  }
}

void toggle_input_off (GtkWidget *widget, GtkToggleButton* button)
{
  gtk_toggle_button_set_active (button, FALSE);
}

int main( int argc, char *argv[] ) {

  /*********** GUI global variables ********************/

  GtkWidget *main_window;
  GtkWidget *frame_webcam;
  GtkWidget *frame_dialog_output;
  GtkWidget *frame_dialog_input;  
  GtkWidget *alignment1;  
  GtkWidget *alignment2;    
  GtkWidget *vbox;
  GtkWidget *dialog;  
  GtkWidget *dialog_output;
  GtkWidget *dialog_input;  
  GtkWidget *fixed_output_text;
  GtkWidget *fixed_output;
  GtkWidget *fixed_state_text;  
  GtkWidget *fixed_state;    
  GtkWidget *fixed_clock;      
  GtkWidget *fixed_light;        
  GtkWidget *fixed_noise;          
  GtkWidget *fixed_reset;        
  GtkWidget *label1;            
  GtkWidget *label2;              

  struct S_GtkWidget* ptr_struct_GtkWidget;
  ptr_struct_GtkWidget= (struct S_GtkWidget*) malloc(sizeof(struct S_GtkWidget));

  gint expand = FALSE;
  gint fill = FALSE;
  gint padding = 0;
  const char* char_current_state="Awake";
  const char* output_current="101";   

  /*****************************************************/

  gtk_init (&argc, &argv);

  capture = cvCaptureFromCAM( CV_CAP_ANY );
  opencvImage = cvQueryFrame( capture );

  /*********************** Main Window ********************************/   

  main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title( GTK_WINDOW( main_window ), "WEBCAM - FPGA Nexys 3");

  g_signal_connect( G_OBJECT( main_window ), "destroy", G_CALLBACK (gtk_main_quit), NULL);

  /*********************** Label Widget *******************************/

  ptr_struct_GtkWidget->output_text=gtk_label_new("Binary : ");
  gtk_widget_set_size_request(ptr_struct_GtkWidget->output_text,50,30);     
  ptr_struct_GtkWidget->output=gtk_label_new(output_current);
  gtk_widget_set_size_request(ptr_struct_GtkWidget->output,50,30);     

  ptr_struct_GtkWidget->label_state=gtk_label_new("State :");
  gtk_widget_set_size_request(ptr_struct_GtkWidget->label_state,50,30);     
  ptr_struct_GtkWidget->label_current_state=gtk_label_new(char_current_state);
  gtk_widget_set_size_request(ptr_struct_GtkWidget->label_current_state,110,30);   

  ptr_struct_GtkWidget->clock=gtk_button_new_with_label("Clock");
  ptr_struct_GtkWidget->reset=gtk_button_new_with_label("Reset");
  ptr_struct_GtkWidget->light=gtk_toggle_button_new_with_label("Light");
  ptr_struct_GtkWidget->noise=gtk_toggle_button_new_with_label("Noise");   

  // Create a Fixed Container 
  fixed_output_text = gtk_fixed_new();
  fixed_output = gtk_fixed_new();
  fixed_state_text = gtk_fixed_new();  
  fixed_state = gtk_fixed_new();    
  fixed_clock = gtk_fixed_new();      
  fixed_light = gtk_fixed_new();        
  fixed_noise = gtk_fixed_new();          
  fixed_reset = gtk_fixed_new();        

  /*********************** Webcam Widget ******************************/      

  ptr_struct_GtkWidget->drawing_area = gtk_drawing_area_new();
  gtk_widget_set_size_request( ptr_struct_GtkWidget->drawing_area, opencvImage->width, opencvImage->height );

  /********************************************************************/

  g_signal_connect( G_OBJECT( ptr_struct_GtkWidget->drawing_area), "expose_event", G_CALLBACK (expose_event_callback), NULL);
  g_timeout_add( 100, ( GSourceFunc )time_handler, ( gpointer ) ptr_struct_GtkWidget->drawing_area );

  // Create Webcam frame
  frame_webcam = gtk_frame_new(NULL);
  gtk_container_set_border_width(GTK_CONTAINER(frame_webcam), 9);
  gtk_frame_set_shadow_type (GTK_FRAME (frame_webcam), GTK_SHADOW_ETCHED_OUT);

  // Add webcam window 
  vbox = gtk_vbox_new (FALSE, 3);
  gtk_container_add (GTK_CONTAINER (frame_webcam), ptr_struct_GtkWidget->drawing_area);;
  gtk_box_pack_start (GTK_BOX (vbox), frame_webcam, expand, fill, padding);     

  // Add dialog  
  dialog = gtk_hbox_new (FALSE,0);    

  // create frame_dialog_output
  frame_dialog_output = gtk_frame_new(NULL);
  gtk_container_set_border_width (GTK_CONTAINER (frame_dialog_output), 12);
  gtk_frame_set_label_align (GTK_FRAME (frame_dialog_output), 0.05, 0.41);
  gtk_frame_set_shadow_type (GTK_FRAME (frame_dialog_output), GTK_SHADOW_ETCHED_OUT);

  alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
  gtk_widget_show (alignment1);
  gtk_container_add (GTK_CONTAINER (frame_dialog_output), alignment1);
  gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 0, 0, 7, 0);

  label1 = gtk_label_new ("<b>Output : </b>");
  gtk_widget_show (label1);
  gtk_frame_set_label_widget (GTK_FRAME (frame_dialog_output), label1);
  gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
  gtk_misc_set_padding (GTK_MISC (label1), 10, 0);

  // Add dialog_output  
  dialog_output = gtk_hbox_new (FALSE,6);    

  gtk_box_pack_start (GTK_BOX (dialog), frame_dialog_output, expand, fill, padding);
  gtk_container_add (GTK_CONTAINER (alignment1), dialog_output);

  // Position of and content of output labels
  gtk_fixed_put(GTK_FIXED (fixed_output_text), ptr_struct_GtkWidget->output_text, 3,5);
  gtk_widget_set_size_request(fixed_output_text, 40, 40);
  gtk_fixed_put(GTK_FIXED (fixed_output), ptr_struct_GtkWidget->output, 6,5);   
  gtk_widget_set_size_request(fixed_output, 40, 40);

  gtk_fixed_put (GTK_FIXED (fixed_state_text), ptr_struct_GtkWidget->label_state, 9,5);            
  gtk_widget_set_size_request(fixed_state_text, 40, 40);
  gtk_fixed_put (GTK_FIXED (fixed_state), ptr_struct_GtkWidget->label_current_state, 12,5);               
  gtk_widget_set_size_request(fixed_state, 127, 40);

  // Position and content of signals buttons
  gtk_fixed_put (GTK_FIXED (fixed_clock), ptr_struct_GtkWidget->clock, 30,0);
  gtk_fixed_put (GTK_FIXED (fixed_light), ptr_struct_GtkWidget->light, 31,0);   
  gtk_fixed_put (GTK_FIXED (fixed_noise), ptr_struct_GtkWidget->noise, 32,0);             
  gtk_fixed_put (GTK_FIXED (fixed_reset), ptr_struct_GtkWidget->reset, 33,0);                   

  gtk_container_add(GTK_CONTAINER( dialog_output), fixed_output_text);
  gtk_container_add(GTK_CONTAINER( dialog_output), fixed_output);
  gtk_container_add(GTK_CONTAINER( dialog_output), fixed_state_text);      
  gtk_container_add(GTK_CONTAINER( dialog_output), fixed_state);

  // Create frame _dialog_input
  frame_dialog_input = gtk_frame_new(NULL);
  gtk_container_set_border_width (GTK_CONTAINER (frame_dialog_input), 12);
  gtk_frame_set_label_align (GTK_FRAME (frame_dialog_input), 0.05, 0.41);
  gtk_frame_set_shadow_type (GTK_FRAME (frame_dialog_input), GTK_SHADOW_ETCHED_OUT);

  alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
  gtk_widget_show (alignment2);
  gtk_container_add (GTK_CONTAINER (frame_dialog_input), alignment2);
  gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 4, 0, 6, 8);

  label2 = gtk_label_new ("<b>Signals : </b>");
  gtk_widget_show (label2);
  gtk_frame_set_label_widget (GTK_FRAME (frame_dialog_input), label2);
  gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
  gtk_misc_set_padding (GTK_MISC (label2), 10, 0);

  // Add dialog input  
  dialog_input = gtk_hbox_new (FALSE,6);      

  gtk_box_pack_start (GTK_BOX (dialog), frame_dialog_input, expand, fill, padding);
  gtk_container_add (GTK_CONTAINER (alignment2), dialog_input);

  gtk_container_add(GTK_CONTAINER( dialog_input), fixed_clock);
  gtk_container_add(GTK_CONTAINER( dialog_input), fixed_light);
  gtk_container_add(GTK_CONTAINER( dialog_input), fixed_noise);
  gtk_container_add(GTK_CONTAINER( dialog_input), fixed_reset);

  // Pack dialog hbox to main vbox 
  gtk_box_pack_start (GTK_BOX (vbox), dialog, expand, fill, padding);

  // Add dialog hbox to main window
  gtk_container_add( GTK_CONTAINER(main_window), vbox);      

  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->clock), "pressed",  G_CALLBACK(input_signal),char_clock);      
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->clock), "released", G_CALLBACK(update_state),ptr_struct_GtkWidget);
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->clock), "released", G_CALLBACK(toggle_input_off),ptr_struct_GtkWidget->light);                  
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->clock), "released", G_CALLBACK(toggle_input_off),ptr_struct_GtkWidget->noise);                     
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->reset), "pressed", G_CALLBACK(input_signal),char_reset);         
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->reset), "released", G_CALLBACK(update_state),ptr_struct_GtkWidget);                  
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->reset), "released", G_CALLBACK(toggle_input_off),ptr_struct_GtkWidget->light);                  
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->reset), "released", G_CALLBACK(toggle_input_off),ptr_struct_GtkWidget->noise);                     


  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->light), "toggled", G_CALLBACK(toggle_button_callback),char_light);         
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->noise), "toggled", G_CALLBACK(toggle_button_callback),char_noise);         

  gtk_widget_show_all( main_window );
  gtk_main();
  cvReleaseCapture( &capture );

  return 0;
}