//pattern.cpp
#include "stdafx.h"
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <math.h>
#include "dst.h"
#include "csv.h"
#include "pattern.h"
#include "helpers.h"
//#include "analyze.h"
//#include "paint.h"
#include "Messaging.h"

//number of stitches to allocate at a time
#define BLOCK_ALLOCATE_SIZE 1000

//////////////////////////////////////////////////////////////////////////
// pattern_config class
void pattern_config::clear() {
	scale=1.0;
	format=0;
};

//////////////////////////////////////////////////////////////////////////
// pattern class
void pattern::clear() {
	//clear out the pattern, but leave allocated space (except variable strings)
	int i;
	for(i=0; i<num_variables; i++) {
		delete(variable_name[i]);
		variable_name[i]=0;
		delete(variable_value[i]);
		variable_value[i]=0;
	};
	num_variables=0;
	stitches=0;
	colors=0;
	messages.clear();
	config.clear();
};

pattern::~pattern() {	// desctructor
	clear();
	free(stitchlist);
	allocated_stitches=0;
	free(colorlist);
	allocated_colors=0;
	free(variable_name);
	free(variable_value);
	allocated_variables=0;
	if(messages.text_buffer_allocated!=0) free(messages.text_buffer);
	messages.text_buffer_allocated=0;
};

pattern::pattern () {	// constructor
	stitches=0;
	stitchlist=0;
	colors=0;
	num_variables=0;

	allocated_stitches=BLOCK_ALLOCATE_SIZE;
	stitchlist = (struct stitch *)malloc(sizeof(struct stitch) * allocated_stitches);
	if (stitchlist==0) {
		fprintf(stderr,"ERROR: failed to alloc %d stitchlist bytes in initialize_pattern().\n",sizeof(struct stitch) * allocated_stitches);
		exit(-1);
	};

	allocated_colors=64;
	colorlist = (struct color*)malloc(sizeof(struct color) * allocated_colors);
	if (colorlist==0) {
		fprintf(stderr,"ERROR: failed to alloc %d color bytes in initialize_pattern().\n",sizeof(struct color) * allocated_colors);
		exit(-1);
	};
	allocated_variables=32;
	variable_name = (char **)malloc(sizeof(char *) * allocated_variables);
	variable_value = (char **)malloc(sizeof(char *) * allocated_variables);
	if (variable_name ==0 || variable_value==0) {
		fprintf(stderr,"ERROR: failed to alloc %d variable_name and variable_value pointers in initialize_pattern.\n",allocated_variables);
		exit(-1);
	};
};

void pattern::set_variable(const char *name, const char *value) {
	int i;
	if (name==0) {
		set_variable("",value); // recursively call with null string instead of null pointer
		return;
	};
	if (value==0) {
		set_variable(name,"");	// recursively call with null string instead of null pointer
		return;
	};
	for (i=0; i<num_variables;i++) {	// variable already defined?, replace the value
		if (stricmp(variable_name[i],name)==0) {
			variable_value[i]=strrealloccopy(variable_value[i],value);
			return;
		};
	};									// variable not defined, add it
	if (num_variables>=allocated_variables) {
		allocated_variables+=32;		// allocate more space for lists of pointers
		variable_name=(char **)realloc(variable_name,sizeof(char *)*allocated_variables);
		variable_value=(char **)realloc(variable_value,sizeof(char *)*allocated_variables);
		if (variable_name ==0 || variable_value==0) {
			fprintf(stderr,"ERROR: failed to alloc %d variable_name and variable_value pointers in initialize_pattern.\n",allocated_variables);
			exit(-1);
		};
	};
	variable_name[num_variables]=stralloccopy(name);
	variable_value[num_variables]=stralloccopy(value);
	num_variables++;
};

char *pattern::get_variable(const char *name) {
	int i;
	for (i=0; i<num_variables;i++) {
		if (stricmp(variable_name[i],name)==0) {
			return(variable_value[i]);
		};
	};
	return(NULL);
};

int pattern::get_variable_int(const char *name) {
	char *val;
	int value=0;
	val=get_variable(name);
	if (val!=0) {
		value=atoi(val);
	};
	return(value);
};

double pattern::get_variable_double(const char *name) {
	char *val;
	double value=0.0;
	val=get_variable(name);
	if (val!=0) {
		value=atof(val);
	};
	return(value);
};

void pattern::delete_variable(const char *name) {
	int i;
	for (i=0; i<num_variables;i++) {
		if (stricmp(variable_name[i],name)==0) {
			free(variable_name[i]);
			free(variable_value[i]);
			num_variables--;
			for (;i<num_variables;i++) {
				variable_name[i]=variable_name[i+1];
				variable_value[i]=variable_value[i+1];
			};
		};
	};
};

int pattern::add_color (COLORREF rgb, const char *description, const char *catalog_number) {
	if (allocated_colors<colors+1) {
		allocated_colors+=64;
		colorlist = (struct color *)realloc(colorlist, sizeof(struct color) * allocated_colors);
	};
	if (colorlist==0) {
		fprintf(stderr,"ERROR: failed to realloc %d bytes in add_color().\n",sizeof(struct stitch) * allocated_stitches);
		exit(-1);
	};
	colorlist[colors].rgb=rgb;
	colorlist[colors].description=stralloccopy(description);
	colorlist[colors].catalog_number=stralloccopy(catalog_number);
//	add("Colors=",colors);
//	add("R",GetRValue(rgb));
//	add("G",GetGValue(rgb));
//	add("B",GetBValue(rgb));
	colors++;
	return(colors);
};

// Three routines to add a stitch to the pattern depending on format...
int pattern::add_stitch_abs (double x, double y, int flags) {
	if (allocated_stitches<stitches+1) {
		allocated_stitches+=BLOCK_ALLOCATE_SIZE;
		stitchlist = (struct stitch *)realloc(stitchlist, sizeof(struct stitch) * allocated_stitches);
	};
	if (stitchlist==0) {
		fprintf(stderr,"ERROR: failed to realloc %d bytes in add_stitch_abs().\n",sizeof(struct stitch) * allocated_stitches);
		exit(-1);
	};
	stitchlist[stitches].xx=x;
	stitchlist[stitches].yy=y;
	stitchlist[stitches].flags=flags;
	stitches++;
	return(stitches);
};

int pattern::add_stitch_rel (double dx, double dy, int flags) {
	double x,y;
	if (stitches>0) {
		x = stitchlist[stitches-1].xx + dx;
		y = stitchlist[stitches-1].yy + dy;
	} else { // the list is empty so assume starting location is 0,0
		x = dx;
		y = dy;
	};
	return(add_stitch_abs(x,y,flags));
};

int pattern::add_stitch_copy (struct stitch src) {
	return(add_stitch_abs(src.xx,src.yy,src.flags));
};

// Delete a stitch from the middle of the list.
int pattern::delete_stitch (int number) {
	int i;
	for (i=number; i<stitches; i++) {
		stitchlist[i]=stitchlist[i+1];
	};
	stitches--;
	return(stitches);
};

// Move a stitch from the end of the list to a position.
// To insert, add stitch normally, then move it to position.
int pattern::move_last_stitch (int number) {
	int i;
	struct stitch temp;

	temp=stitchlist[stitches-1];
	for (i=stitches-1; i>number; i--) {
		stitchlist[i]=stitchlist[i-1];
	};
	stitchlist[number]=temp;
	return(stitches);
};

// A simple list of the stitches, handy for debugging.  (obsoleted by csv_write)
/*
void pattern::print_stitchlist (char *filename) {
	double xx,yy,dx,dy;
	int flags;
	int i;
	FILE *fout;
	double length;

	fout = fopen(filename,"w");
	if (fout==0) {
		fprintf(stderr, "Error opening %s for write\n",filename);
		//exit(-1);
	};

	xx=yy=0.0;
	for (i=0;i<stitches;i++) {
		dx=stitchlist[i].xx - xx;
		dy=stitchlist[i].yy - yy;
		xx=stitchlist[i].xx;
		yy=stitchlist[i].yy;
		flags=stitchlist[i].flags;
		length=sqrt(dx * dx + dy * dy);
		fprintf(fout," %7d: %6.2lf,%6.2lf (%6.2lf) (%6d,%6d) : ",i+1,dx,dy,length,xx,yy);
		switch(flags) {
		case NORMAL:
			fprintf(fout,"Normal Stitch\n");
			break;
		case END:
			fprintf(fout,"End\n");
			break;
		case JUMP:
			fprintf(fout,"Jump Stitch\n");
			break;
		case STOP:
			fprintf(fout,"Stop/Color\n");
			break;
		default:
			fprintf(fout,"Unknown\n");
			break;
		};
	};

	fclose (fout);
//	analysis_dump(this,"analysis.txt");
};
*/

// read or write files using .DST file format
BOOL pattern::read_dst(const char *filename) {
	return(dst_read(this,filename));
};
BOOL pattern::write_dst(const char *filename) {
	return(dst_write(this,filename));
};

//void pattern::read_dst(CFile *dstin) {
//	dst_read(this,dstin);
//};
//void pattern::write_dst(CFile *dstout) {
//	dst_write(this,dstout);
//};

// read or write files using .CSV file format
BOOL pattern::read_csv(const char *filename) {
	return(csv_read(this,filename));
};
BOOL pattern::write_csv(const char *filename) {
	return(csv_write(this,filename));
};

//void pattern::read_csv(CFile *csvin) {
//	csv_read(this,csvin);
//};
//void pattern::write_csv(CFile *csvout) {
//	csv_write(this,csvout);
//};


// Very simple scaling of the x and y axis for every point.
// Doesn't insert or delete stitches to preserve density.
void pattern::scale_pattern (double scale) {
	int i;
	for (i=0;i<stitches;i++) {
		stitchlist[i].xx=stitchlist[i].xx*scale;
		stitchlist[i].yy=stitchlist[i].yy*scale;
	};
};

void pattern::statistics (void) {
	int colors=1;
	int real_stitches=0;
	int jump_stitches=0;
	int unknown_stitches=0;
	double minx=0,maxx=0,miny=0,maxy=0;
	double min_stitchlength=999.0;
	double max_stitchlength=0.0;
	double total_stitchlength=0.0;
	int number_of_minlength_stitches=0;
	int number_of_maxlength_stitches=0;
	
	int i;
	double xx=0,yy=0;
	double dx=0,dy=0;
	double length=0.0;

	if (stitches ==0) {
		messages.add("No design loaded\n");
		return;
	};

	for (i=0;i<stitches;i++) {
		dx=stitchlist[i].xx-xx;
		dy=stitchlist[i].yy-yy;
		xx=stitchlist[i].xx;
		yy=stitchlist[i].yy;
		length=sqrt(dx * dx + dy * dy);
		if (i>0 && stitchlist[i-1].flags!=NORMAL) length=0.0;	//can't count first normal stitch;
		switch(stitchlist[i].flags) {
			case NORMAL:
				real_stitches++;
				if(length>max_stitchlength) {max_stitchlength=length; number_of_maxlength_stitches=0;};
				if(length==max_stitchlength) number_of_maxlength_stitches++;
				if(length>0 && length<min_stitchlength) {min_stitchlength=length; number_of_minlength_stitches=0;};
				if(length==min_stitchlength) number_of_minlength_stitches++;
				total_stitchlength+=length;
				if(xx<minx) minx=xx;
				if(xx>maxx) maxx=xx;
				if(yy<miny) miny=yy;
				if(yy>maxy) maxy=yy;
				break;
			case JUMP:
				jump_stitches++;
				break;
			case STOP:
				colors++;
				break;
			case END:
				break;
			default:
				unknown_stitches++;
				break;
		};
	};

	//second pass to fill bins now that we know max stitch length
#define NUMBINS 10
	int bin[NUMBINS+1];
	for (i=0;i<=NUMBINS;i++) {
		bin[i]=0;
	};

	for (i=0;i<stitches;i++) {
		dx=stitchlist[i].xx-xx;
		dy=stitchlist[i].yy-yy;
		xx=stitchlist[i].xx;
		yy=stitchlist[i].yy;
		if (i>0 && stitchlist[i-1].flags==NORMAL && stitchlist[i].flags == NORMAL) {
			length=sqrt(dx * dx + dy * dy);
			bin[int(floor(NUMBINS*length/max_stitchlength))]++;
		};
	};

	char buf[1000];
	messages.clear();
	sprintf(buf,"Design name: %s\n",get_variable("design_name"));
	messages.add(buf);
	sprintf(buf,"Number of stitch entries: %d\n",stitches);
	messages.add(buf);
	sprintf(buf,"  Real stitches: %d\n",real_stitches);
	messages.add(buf);
	sprintf(buf,"  Jump stitches: %d\n",jump_stitches);
	messages.add(buf);
	sprintf(buf,"  Colors: %d\n",colors);
	messages.add(buf);
	sprintf(buf,"  Unknown stitches: %d\n",unknown_stitches);
	messages.add(buf);
	sprintf(buf,"Design width x height = %.1lf x %.1lf\n",maxx-minx,maxy-miny);
	messages.add(buf);
	sprintf(buf,"Center of design = %.1lf,%.1lf\n",(maxx+minx)/2.0,(maxy+miny)/2.0);
	messages.add(buf);
	sprintf(buf,"Total length of stitches: %.2lf\n",total_stitchlength);
	messages.add(buf);
	sprintf(buf,"Maximum stitch length: %.2lf (%d at this length)\n",max_stitchlength, number_of_maxlength_stitches);
	messages.add(buf);
	sprintf(buf,"Minimum stitch length: %.2lf (%d at this length)\n",min_stitchlength, number_of_minlength_stitches);
	messages.add(buf);
	sprintf(buf,"Average length of stitches: %.2lf\n",total_stitchlength/real_stitches);
	messages.add(buf);
	sprintf(buf,"Stitch length distribution:\n");
	messages.add(buf);
	for (i=0;i<NUMBINS-1;i++) {
		sprintf(buf," %6.2lf-%6.2lf == %d\n",i * max_stitchlength/NUMBINS,(i+1) * max_stitchlength/NUMBINS,bin[i]);
		messages.add(buf);
	};
	sprintf(buf," %6.2lf-%6.2lf == %d\n",i * max_stitchlength/NUMBINS,(i+1) * max_stitchlength/NUMBINS,bin[i]+bin[i+1]);
	messages.add(buf);
	
};

void pattern::create_test(void) {

	clear();
	set_variable("file_name","test7.csv");
	set_variable("design_name","TEST7");
	add_stitch_abs( 0.0, 0.0,JUMP);
	add_stitch_abs( 3.0, 3.0,JUMP);
	add_stitch_abs( 3.0, 3.0,NORMAL);
	add_stitch_abs(-3.0, 3.0,NORMAL);
	add_stitch_abs(-3.0,-3.0,NORMAL);
	add_stitch_abs( 3.0,-3.0,NORMAL);
	add_stitch_abs( 3.0, 3.0,NORMAL);
	add_stitch_abs(-3.0, 3.0,NORMAL);
	add_stitch_abs( 0.0, 0.0,JUMP);
	add_stitch_abs( 0.0, 0.0,END);
	add_color(RGB(rand()%256,rand()%256,rand()%256),"Random","");
};

struct lfRECT pattern::get_dimensions(void) {
	struct lfRECT dim;
	int i; 
	double xx,yy;
	dim.top=dim.bottom=dim.left=dim.right=0;

	for (i=0;i<stitches;i++) {
		xx=stitchlist[i].xx;
		yy=stitchlist[i].yy;
		if(xx<dim.left)   dim.left=xx;
		if(xx>dim.right)  dim.right=xx;
		if(yy<dim.top)    dim.top=yy;
		if(yy>dim.bottom) dim.bottom=yy;
	};
	return (dim);
};

void pattern::calculate_angles(void) {
	double xx,yy,dx,dy;
	int flags;
	int i;
	xx=yy=0.0;

	double pi = 3.1415926535;

	for (i=0;i<stitches;i++) {
		//initialize all to -999 to indicate invalid.
		stitchlist[i].a= -999;
		stitchlist[i].da=-999;
		stitchlist[i].l= -999;
	};

	for (i=0;i<stitches;i++) {
		dx=stitchlist[i].xx - xx;
		dy=stitchlist[i].yy - yy;
		xx=stitchlist[i].xx;
		yy=stitchlist[i].yy;
		flags=stitchlist[i].flags;
		stitchlist[i].l = sqrt(dx * dx + dy * dy); // length into this point
		
		if (flags!=JUMP) {
			stitchlist[i].a = atan2(dy,dx) *180.0/pi;	// angle of line into this point
			if (stitchlist[i].l==0) {
				stitchlist[i].a=-999;
			};
		};
	};
	for (i=0;i<stitches-1;i++) {
		if (stitchlist[i].a !=-999 && stitchlist[i+1].a !=-999) {
			stitchlist[i].da = stitchlist[i+1].a-stitchlist[i].a;
		};
	};
};

/*
int pattern::load(CFile *fp) {
	CString filename = fp->GetFileName();
	CString extension = filename.Right(3);
		
	if (extension.CompareNoCase("dst")==0) {
		status("Loading DST file:",filename);
//		read_dst(fp);
		status("Done loading",filename);
	} else if (extension.CompareNoCase("csv")==0) {
		status("Loading CSV file:",filename);
		read_csv(fp);
		status("Done loading",filename);
	} else {
		status("Error: Unknown file type",extension);
		return(FALSE);
	};
	status_updateall(this);

	//force_refresh_all();
	return(TRUE);
};

int pattern::save(CFile *fp) {
	CString filename = fp->GetFileName();
	CString extension = filename.Right(3);

	if (extension.CompareNoCase("dst")==0) {
		status("Saving DST file:",filename);
//		write_dst(fp);
		status("Done saving",filename);
	} else if (extension.CompareNoCase("csv")==0) {
		status("Saving CSV file:",filename);
		write_csv(fp);
		status("Done saving",filename);
	} else {
		status("Error: Unknown file type",extension);
		return(FALSE);
	};
	status_updateall(this);

	//force_refresh_all();
	return(TRUE);
};
*/