#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <list>
#include "../../svm.h"
using namespace std;

#define DEFAULT_PARAM "-t 2 -c 100"
#define XLEN 500
#define YLEN 500
#define DrawLine(dc,x1,y1,x2,y2,c) \
	do { \
		HPEN hpen = CreatePen(PS_SOLID,0,c); \
		HPEN horig = SelectPen(dc,hpen); \
		MoveToEx(dc,x1,y1,NULL); \
		LineTo(dc,x2,y2); \
		SelectPen(dc,horig); \
		DeletePen(hpen); \
	} while(0)

using namespace std;

COLORREF colors[] =
{
	RGB(0,0,0),
	RGB(0,120,120),
	RGB(120,120,0),
	RGB(120,0,120),
	RGB(0,200,200),
	RGB(200,200,0),
	RGB(200,0,200)
};

HWND main_window;
HBITMAP buffer;
HDC window_dc;
HDC buffer_dc;
HBRUSH brush1, brush2, brush3;
HWND edit;

enum {
	ID_BUTTON_CHANGE, ID_BUTTON_RUN, ID_BUTTON_CLEAR,
	ID_BUTTON_LOAD, ID_BUTTON_SAVE, ID_EDIT
};

struct point {
	double x, y;
	signed char value;
};

list<point> point_list;
int current_value = 1;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
		   PSTR szCmdLine, int iCmdShow)
{
	static char szAppName[] = "SvmToy";
	MSG msg;
	WNDCLASSEX wndclass;

	wndclass.cbSize = sizeof(wndclass);
	wndclass.style = CS_HREDRAW | CS_VREDRAW;
	wndclass.lpfnWndProc = WndProc;
	wndclass.cbClsExtra = 0;
	wndclass.cbWndExtra = 0;
	wndclass.hInstance = hInstance;
	wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
	wndclass.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
	wndclass.lpszMenuName = NULL;
	wndclass.lpszClassName = szAppName;
	wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

	RegisterClassEx(&wndclass);

	main_window = CreateWindow(szAppName,	// window class name
				    "SVM Toy",	// window caption
				    WS_OVERLAPPEDWINDOW,// window style
				    CW_USEDEFAULT,	// initial x position
				    CW_USEDEFAULT,	// initial y position
				    XLEN,	// initial x size
				    YLEN+52,	// initial y size
				    NULL,	// parent window handle
				    NULL,	// window menu handle
				    hInstance,	// program instance handle
				    NULL);	// creation parameters

	ShowWindow(main_window, iCmdShow);
	UpdateWindow(main_window);

	CreateWindow("button", "Change", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		     0, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_CHANGE, hInstance, NULL);
	CreateWindow("button", "Run", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		     50, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_RUN, hInstance, NULL);
	CreateWindow("button", "Clear", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		     100, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_CLEAR, hInstance, NULL);
	CreateWindow("button", "Save", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		     150, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_SAVE, hInstance, NULL);
	CreateWindow("button", "Load", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		     200, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_LOAD, hInstance, NULL);

	edit = CreateWindow("edit", NULL, WS_CHILD | WS_VISIBLE,
		            250, YLEN, 250, 25, main_window, (HMENU) ID_EDIT, hInstance, NULL);

	Edit_SetText(edit,DEFAULT_PARAM);

	brush1 = CreateSolidBrush(colors[4]);
	brush2 = CreateSolidBrush(colors[5]);
	brush3 = CreateSolidBrush(colors[6]);

	window_dc = GetDC(main_window);
	buffer = CreateCompatibleBitmap(window_dc, XLEN, YLEN);
	buffer_dc = CreateCompatibleDC(window_dc);
	SelectObject(buffer_dc, buffer);
	PatBlt(buffer_dc, 0, 0, XLEN, YLEN, BLACKNESS);

	while (GetMessage(&msg, NULL, 0, 0)) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	return msg.wParam;
}

int getfilename( HWND hWnd , char *filename, int len, int save)
{
	OPENFILENAME OpenFileName;
	memset(&OpenFileName,0,sizeof(OpenFileName));
	filename[0]='\0';

	OpenFileName.lStructSize       = sizeof(OPENFILENAME);
	OpenFileName.hwndOwner         = hWnd;
	OpenFileName.lpstrFile         = filename;
	OpenFileName.nMaxFile          = len;
	OpenFileName.Flags             = 0;

	return save?GetSaveFileName(&OpenFileName):GetOpenFileName(&OpenFileName);
}

void clear_all()
{
	point_list.clear();
	PatBlt(buffer_dc, 0, 0, XLEN, YLEN, BLACKNESS);
	InvalidateRect(main_window, 0, 0);
}

HBRUSH choose_brush(int v)
{
	if(v==1) return brush1;
	else if(v==2) return brush2;
	else return brush3;
}

void draw_point(const point & p)
{
	RECT rect;
	rect.left = int(p.x*XLEN);
	rect.top = int(p.y*YLEN);
	rect.right = int(p.x*XLEN) + 3;
	rect.bottom = int(p.y*YLEN) + 3;
	FillRect(window_dc, &rect, choose_brush(p.value));
	FillRect(buffer_dc, &rect, choose_brush(p.value));
}

void draw_all_points()
{
	for(list<point>::iterator p = point_list.begin(); p != point_list.end(); p++)
		draw_point(*p);
}

void button_run_clicked()
{
	// guard
	if(point_list.empty()) return;

	svm_parameter param;
	int i,j;

	// default values
	param.svm_type = C_SVC;
	param.kernel_type = RBF;
	param.degree = 3;
	param.gamma = 0;
	param.coef0 = 0;
	param.nu = 0.5;
	param.cache_size = 100;
	param.C = 1;
	param.eps = 1e-3;
	param.p = 0.1;
	param.shrinking = 1;
	param.probability = 0;
	param.nr_weight = 0;
	param.weight_label = NULL;
	param.weight = NULL;

	// parse options
	char str[1024];
	Edit_GetLine(edit, 0, str, sizeof(str));
	const char *p = str;

	while (1) {
		while (*p && *p != '-')
			p++;

		if (*p == '\0')
			break;

		p++;
		switch (*p++) {
			case 's':
				param.svm_type = atoi(p);
				break;
			case 't':
				param.kernel_type = atoi(p);
				break;
			case 'd':
				param.degree = atoi(p);
				break;
			case 'g':
				param.gamma = atof(p);
				break;
			case 'r':
				param.coef0 = atof(p);
				break;
			case 'n':
				param.nu = atof(p);
				break;
			case 'm':
				param.cache_size = atof(p);
				break;
			case 'c':
				param.C = atof(p);
				break;
			case 'e':
				param.eps = atof(p);
				break;
			case 'p':
				param.p = atof(p);
				break;
			case 'h':
				param.shrinking = atoi(p);
				break;
			case 'b':
				param.probability = atoi(p);
				break;
			case 'w':
				++param.nr_weight;
				param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight);
				param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight);
				param.weight_label[param.nr_weight-1] = atoi(p);
				while(*p && !isspace(*p)) ++p;
				param.weight[param.nr_weight-1] = atof(p);
				break;
		}
	}

	// build problem
	svm_problem prob;

	prob.l = point_list.size();
	prob.y = new double[prob.l];

	if(param.kernel_type == PRECOMPUTED)
	{
	}
	else if(param.svm_type == EPSILON_SVR ||
		param.svm_type == NU_SVR)
	{
		if(param.gamma == 0) param.gamma = 1;
		svm_node *x_space = new svm_node[2 * prob.l];
		prob.x = new svm_node *[prob.l];

		i = 0;
		for (list<point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++)
		{
			x_space[2 * i].index = 1;
			x_space[2 * i].value = q->x;
			x_space[2 * i + 1].index = -1;
			prob.x[i] = &x_space[2 * i];
			prob.y[i] = q->y;
		}

		// build model & classify
		svm_model *model = svm_train(&prob, &param);
		svm_node x[2];
		x[0].index = 1;
		x[1].index = -1;
		int *j = new int[XLEN];

		for (i = 0; i < XLEN; i++)
		{
			x[0].value = (double) i / XLEN;
			j[i] = (int)(YLEN*svm_predict(model, x));
		}

		DrawLine(buffer_dc,0,0,0,YLEN,colors[0]);
		DrawLine(window_dc,0,0,0,YLEN,colors[0]);

		int p = (int)(param.p * YLEN);
		for(int i=1; i < XLEN; i++)
		{
			DrawLine(buffer_dc,i,0,i,YLEN,colors[0]);
			DrawLine(window_dc,i,0,i,YLEN,colors[0]);

			DrawLine(buffer_dc,i-1,j[i-1],i,j[i],colors[5]);
			DrawLine(window_dc,i-1,j[i-1],i,j[i],colors[5]);

			if(param.svm_type == EPSILON_SVR)
			{
				DrawLine(buffer_dc,i-1,j[i-1]+p,i,j[i]+p,colors[2]);
				DrawLine(window_dc,i-1,j[i-1]+p,i,j[i]+p,colors[2]);

				DrawLine(buffer_dc,i-1,j[i-1]-p,i,j[i]-p,colors[2]);
				DrawLine(window_dc,i-1,j[i-1]-p,i,j[i]-p,colors[2]);
			}
		}

		svm_free_and_destroy_model(&model);
		delete[] j;
		delete[] x_space;
		delete[] prob.x;
		delete[] prob.y;
	}
	else
	{
		if(param.gamma == 0) param.gamma = 0.5;
		svm_node *x_space = new svm_node[3 * prob.l];
		prob.x = new svm_node *[prob.l];

		i = 0;
		for (list<point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++)
		{
			x_space[3 * i].index = 1;
			x_space[3 * i].value = q->x;
			x_space[3 * i + 1].index = 2;
			x_space[3 * i + 1].value = q->y;
			x_space[3 * i + 2].index = -1;
			prob.x[i] = &x_space[3 * i];
			prob.y[i] = q->value;
		}

		// build model & classify
		svm_model *model = svm_train(&prob, &param);
		svm_node x[3];
		x[0].index = 1;
		x[1].index = 2;
		x[2].index = -1;

		for (i = 0; i < XLEN; i++)
			for (j = 0; j < YLEN; j++) {
				x[0].value = (double) i / XLEN;
				x[1].value = (double) j / YLEN;
				double d = svm_predict(model, x);
				if (param.svm_type == ONE_CLASS && d<0) d=2;
				SetPixel(window_dc, i, j, colors[(int)d]);
				SetPixel(buffer_dc, i, j, colors[(int)d]);
			}

		svm_free_and_destroy_model(&model);
		delete[] x_space;
		delete[] prob.x;
		delete[] prob.y;
	}
	free(param.weight_label);
	free(param.weight);
	draw_all_points();
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
	HDC hdc;
	PAINTSTRUCT ps;

	switch (iMsg) {
	case WM_LBUTTONDOWN:
		{
			int x = LOWORD(lParam);
			int y = HIWORD(lParam);
			point p = {(double)x/XLEN, (double)y/YLEN, current_value};
			point_list.push_back(p);
			draw_point(p);
		}
		return 0;
	case WM_PAINT:
		{
			hdc = BeginPaint(hwnd, &ps);
			BitBlt(hdc, 0, 0, XLEN, YLEN, buffer_dc, 0, 0, SRCCOPY);
			EndPaint(hwnd, &ps);
		}
		return 0;
	case WM_COMMAND:
		{
			int id = LOWORD(wParam);
			switch (id) {
			case ID_BUTTON_CHANGE:
				++current_value;
				if(current_value > 3) current_value = 1;
				break;
			case ID_BUTTON_RUN:
				button_run_clicked();
				break;
			case ID_BUTTON_CLEAR:
				clear_all();
				break;
			case ID_BUTTON_SAVE:
				{
					char filename[1024];
					if(getfilename(hwnd,filename,1024,1))
					{
						FILE *fp = fopen(filename,"w");

						char str[1024];
						Edit_GetLine(edit, 0, str, sizeof(str));
						const char *p = str;
						const char* svm_type_str = strstr(p, "-s ");
						int svm_type = C_SVC;
						if(svm_type_str != NULL)
							sscanf(svm_type_str, "-s %d", &svm_type);

						if(fp)
						{
							if(svm_type == EPSILON_SVR || svm_type == NU_SVR)
							{
								for(list<point>::iterator p = point_list.begin(); p != point_list.end();p++)
									fprintf(fp,"%f 1:%f\n", p->y, p->x);
							}
							else
							{
								for(list<point>::iterator p = point_list.begin(); p != point_list.end();p++)
									fprintf(fp,"%d 1:%f 2:%f\n", p->value, p->x, p->y);
							}
							fclose(fp);
						}
					}
				}
				break;
			case ID_BUTTON_LOAD:
				{
					char filename[1024];
					if(getfilename(hwnd,filename,1024,0))
					{
						FILE *fp = fopen(filename,"r");
						if(fp)
						{
							clear_all();
							char buf[4096];
							while(fgets(buf,sizeof(buf),fp))
							{
								int v;
								double x,y;
								if(sscanf(buf,"%d%*d:%lf%*d:%lf",&v,&x,&y)==3)
								{
									point p = {x,y,v};
									point_list.push_back(p);
								}
								else if(sscanf(buf,"%lf%*d:%lf",&y,&x)==2)
								{
									point p = {x,y,current_value};
									point_list.push_back(p);
								}
								else
									break;
							}
							fclose(fp);
							draw_all_points();
						}
					}
				}
				break;
			}
		}
		return 0;
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}

	return DefWindowProc(hwnd, iMsg, wParam, lParam);
}
