#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <string.h>
#include <misc.h>
#include <tlmplib.h>
#include <string>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

static string tput(const char *s)
{
	string ret = "";
	string cmd = string("tput ") + s;
	FILE *fin = popen(cmd.c_str(),"r");
	if (fin != NULL){
		int c;
		while ((c=fgetc(fin))!=EOF){
			ret += (char)c;
		}
		pclose (fin);
	}
	return ret;
}

struct VIEW{
	string name;
	string description;
	VIEW(const char *_name, const char *_desc){
		name = _name;
		description = _desc;
	}
};
<mod>
static vector<string> readmodes()
{
	glocal vector<string> v;
	string optsdir = string(getenv("HOME")) + "/.Slic3r/modes";
	<call walkfs>(optsdir.c_str());
	<f onefile>
		if (strcmp(basename,"pla.opts")!=0
			&& strcmp(basename,"abs.opts")!=0){
			const char *pt = strchr(basename,'.');
			if (pt != NULL){
				glocal.v.push_back(string(basename,pt-basename));
			}
		}
	</f>
	</call>
	sort(glocal.v.begin(),glocal.v.end());
	return glocal.v;
}
enum VIEWMODE{
	VIEW_STD,VIEW_TEST,VIEW_PRINT
};
</mod>
static string def = string(getenv("HOME")) + "/.Slic3r/viewsel.def";
struct OPTIONS{
	string material;
	VIEWMODE viewmode;
	OPTIONS(){
		material="pla";
		viewmode = VIEW_STD;
		read ();
	}
	void save();
	void read();
};
<mod>
void OPTIONS::read()
{
	glocal OPTIONS *o = this;
	<call loadfile>(def.c_str(),true);
	<f missing>
	</f>
	<f oneline>
		if (strncmp(line,"material=",9)==0){
			glocal.o->material = line+9;
		}
		return 0;
	</f>
	</call>
}
</mod>
<mod>
void OPTIONS::save()
{
	glocal OPTIONS *o = this;
	<call savefile>(def.c_str(),false);
	<f dowrite>
		fprintf (fout,"material=%s\n",glocal.o->material.c_str());
		return 0;
	</f>
	</call>
}
</mod>


<mod>
static vector<VIEW> buildviews (const char *opt, const char *fname)
{
	glocal vector<VIEW> v;
	string cmd = string("buildviews ") + opt + " " + fname;
	//printf ("buildviews: %s\n",cmd.c_str());
	<call walkpopen>(cmd.c_str(),10,true);
	<f oneline>
		//printf ("line=%s\n",line);
		string word;
		const char *pt = str_copyword(word,line);
		glocal.v.push_back(VIEW(word.c_str(),pt));
		return 0;
	</f>
	</call>
	return glocal.v;
}
</mod>
<mod>
static void viewsel_readopts(const char *cmd, map<string,string> &result)
{
	glocal map<string,string> *result = &result;
	<call walkpopen>(cmd,20,true);
	<f oneline>
		line = str_skip(line);
		if (line[0] == '-' && line[1] == '-'){
			line += 2;
			const char *pteq = strchr(line,'=');
			if (pteq != NULL){
				string var = string(line,pteq-line);
				for (unsigned i=0; i<var.size(); i++){
					if (var[i] == '-') var[i] = '_';
				}
				(*glocal.result)[var] = pteq+1;
			}
		}
		return 0;
	</f>
	</call>
}


struct PRINTINFO{
	int repeatx,repeaty;
	int offx,offy;
	PRINTINFO(){
		repeatx = 1;
		repeaty = 1;
		offx = 50;
		offy = 50;
	}
};

<mod>
static void viewsel_create_header(
	const string &viewh,	// Header to create
	const char *fname,
	const string &material,
	const vector<string> &views,	// Name of the views to present or print
	const PRINTINFO &aprint,
	bool printing,
	const vector<string> &slicopts)
{
	glocal const vector<string> *views = &views;
	glocal const char *fname = fname;
	glocal const char *material = material.c_str();
	glocal bool printing = printing;
	glocal const PRINTINFO *aprint = &aprint;
	glocal map<string,string> result;
	{
		char tmp[1000];
		snprintf (tmp,sizeof(tmp)-1,"export material=%s; ~/.Slic3r/printer.opts",glocal.material);
		viewsel_readopts(tmp,glocal.result);
		snprintf (tmp,sizeof(tmp)-1,"oscad-readopts -c -o viewsopts %s",glocal.fname);
		viewsel_readopts(tmp,glocal.result);
		snprintf (tmp,sizeof(tmp)-1,"oscad-readopts -c -o viewopts --optname2 %s %s",views[0].c_str(),glocal.fname);
		viewsel_readopts(tmp,glocal.result);
		for (unsigned i=0; i<slicopts.size(); i++){
			const char *opt = slicopts[i].c_str();
			string file = string(getenv("HOME")) + string("/.Slic3r/modes/") + string(opt) + ".opts";
			struct stat st;
			if (stat(file.c_str(),&st)==-1){
				tlmp_error ("Slice option %s does not exist\n",opt);
			}else if ((st.st_mode & 0111) != 0){
				snprintf (tmp,sizeof(tmp)-1,"%s",file.c_str());
				viewsel_readopts(tmp,glocal.result);
			}else{
				snprintf (tmp,sizeof(tmp)-1,"cat %s",file.c_str());
				viewsel_readopts(tmp,glocal.result);
			}
		}

	}
	<call savefile>(viewh.c_str(),false);
	<f dowrite>
		//fprintf (fout,"view=\"%s\";\n",(*glocal.views)[0].c_str());
		fprintf (fout,"views=[");
		for (unsigned i=0; i<glocal.views->size(); i++){
			if (i > 0) fprintf (fout,",");
			fprintf (fout,"\"%s\"",(*glocal.views)[i].c_str());
		}
		fprintf (fout,"];\n");
		fprintf (fout,"vs_printing=%s;\n",glocal.printing ? "true" : "false");
		fprintf (fout,"vs_material=\"%s\";\n",glocal.material);
		for (map<string,string>::iterator it = glocal.result.begin(); it != glocal.result.end(); it++){
			const char *sep = "";
			if (!isdigit(it->second[0])) sep = "\"";
			fprintf (fout,"vs_%s=%s%s%s;\n",it->first.c_str(),sep,it->second.c_str(),sep);
		}
		fprintf (fout,"vs_repeatx=%d;\n",glocal.aprint->repeatx);
		fprintf (fout,"vs_repeaty=%d;\n",glocal.aprint->repeaty);
		fprintf (fout,"vs_repeat_offx=%d;\n",glocal.aprint->offx);
		fprintf (fout,"vs_repeat_offy=%d;\n",glocal.aprint->offy);
		fprintf (fout,"for(o=[0:len(views)-1]){\n");
    		fprintf (fout,"\tview=views[o];\n");
		fprintf (fout,"\tfor (x=[0:vs_repeatx-1]){\n");
        	fprintf (fout,"\t\tfor (y=[0:vs_repeaty-1]){\n");
		fprintf (fout,"\t\t\ttranslate([x*vs_repeat_offx,(o*vs_repeaty+y)*vs_repeat_offy,0]) main_view(view);\n");
		fprintf (fout,"\t\t}\n");
		fprintf (fout,"\t}\n");
		fprintf (fout,"}\n");
		return 0;
	</f>
	</call>
}
</mod>
static void viewsel_create_header(
	const string &viewh,	// Header to create
	const char *fname,
	const string &material,
	const vector<string> &views,	// Name of the views
	const string &opt,
	bool printing,
	const vector<string> &slicopts)
{
	PRINTINFO info;
	vector<string> tb;
	int n = str_splitline(opt.c_str(),',',tb);
	for (int i=0; i<n; i++){
		const char *s = tb[i].c_str();
		if (s[0] == 'x'){
			info.repeatx = atoi(s+1);
		}else if (s[0] == 'y'){
			info.repeaty = atoi(s+1);
		}else if (s[0] == 'w'){
			info.offx = atoi(s+1);
		}else if (s[0] == 'h'){
			info.offy = atoi(s+1);
		}else{
		}
	}
	viewsel_create_header(viewh,fname,material,views,info,printing,slicopts);
}

static void viewsel_create_header(
	const string &viewh,	// Header to create
	const char *fname,
	const string &material,
	const string &view,	// Name of the view
	bool printing)
{
	vector<string> views;
	views.push_back(view);
	string opt;
	vector<string> sopts;
	viewsel_create_header(viewh,fname,material,views,opt,printing,sopts);
}


static bool viewsel_isnum(const char *pt)
{
	bool ret = false;
	if (isdigit(*pt)){
		while (isdigit(*pt)) pt++;
		ret = *pt == '\0' || *pt == ' ' || *pt == ',' || *pt == ':';
	}
	return ret;
}
static int viewsel_parsecmd (
	const char *cmd,
	const vector<VIEW> &menu,	// Available views
	vector<string> &views,
	string &opt,
	bool &printview,	// Request the same view as if print was requested
	bool &print,		// request an stl file and gcode
	const char *&pt,
	int level)		// Recursion level
{
	int ret = 0;
	printview = false;
	print = false;
	views.clear();
	opt = "";
	pt = cmd;
	if (*pt == '='){
		printview = true;
		pt++;
	}
	if (*pt == '!'){
		printview = true;
		print = true;
		pt++;
	}
	while (*pt > ' ' && *pt != ':'){
		if (viewsel_isnum(pt)){
			unsigned num = atoi(pt);
			pt = str_skipdig(pt);
			if (num < 1 || num > menu.size()){
				printf ("\nInvalid selection %u\n",num);
				ret = -1;
			}else{
				string view = menu[num-1].name;
				if (level == 0){
					const char *ppt;
					bool nprintview;
					bool nprint;
					string nopt;
					vector<string> nviews;
					if (viewsel_parsecmd(view.c_str(),menu,nviews,nopt,nprintview,nprint,ppt,1)==-1){
						printf ("\nInvalid view %s\n",view.c_str());
					}else{
						for (unsigned i=0; i<nviews.size(); i++) views.push_back(nviews[i]);
						opt += nopt;
					}
				}else{
					views.push_back(view);
				}
			}
		}else{
			string view;
			while (*pt > ' ' && *pt != ',' && *pt != ':'){
				view += *pt++;
			}
			bool found = false;
			for (unsigned i=0; i<menu.size(); i++){
				if (view == menu[i].name){
					found = true;
					break;
				}
			}
			if (!found){
				printf ("\nUnknown view %s\n",view.c_str());
				ret = -1;
			}else{
				views.push_back(view);
			} 
		}
			
		if (*pt == ',') pt++;
	}
	if (*pt == ':'){
		pt++;
		while (*pt > ' ') opt += *pt++;
	}
	return ret;
}
static int viewsel_parsecmd (
	const char *cmd,
	const vector<VIEW> &menu,	// Available views
	vector<string> &views,
	string &opt,
	bool &printview,
	bool &print,
	const char *&pt)
{
	return viewsel_parsecmd(cmd,menu,views,opt,printview,print,pt,0);
}


static void viewsel_append (vector<VIEW> &allv, vector<VIEW> &v)
{
	for (unsigned i=0; i<v.size(); i++){
		allv.push_back(v[i]);
	}
}
<mod>
int main (int argc, char *argv[])
{
	glocal const char *parse = NULL;
	glocal const char *scadfile = NULL;
	glocal const char *material = "pla";
	glocal vector<string> slicopts;
	glocal int ret = -1;
	glocal.ret = <call tlmpprogram>(argc,argv);
	<f init>
		setarg ('p',"parseview","Parse a view and generate all the variables",glocal.parse,false);
		setarg ('s',"scadfile","SCAD file to retrieve view options",glocal.scadfile,false);
		setarg ('o',"slicopt","Slic3r option files",glocal.slicopts,false);
	</f>
	<f main_noarg>
		int ret = -1;
		if (glocal.parse != NULL && glocal.scadfile != NULL){
			vector<string> views;
			string opt;
			bool printview,print;
			const char *pt;
			OPTIONS options;
			vector<VIEW> v = buildviews("--list",glocal.scadfile);
			vector<VIEW> tests = buildviews("--listtest",glocal.scadfile);
			vector<VIEW> prints = buildviews("--listprint",glocal.scadfile);
			for (unsigned i=0; i<tests.size(); i++) v.push_back(tests[i]);
			for (unsigned i=0; i<prints.size(); i++) v.push_back(prints[i]);
			if (viewsel_parsecmd(glocal.parse,v,views,opt,printview,print,pt)!=-1){
				viewsel_create_header("-",glocal.scadfile,options.material,views,opt,printview,glocal.slicopts);
				ret = 0;
			}
		}else{
			usage();
		}
		return ret;
	</f>
	<f main>
		int ret = -1;
		if (argc != 1){
			usage();
		}else if (!file_exist(argv[0])){
			tlmp_error ("File %s does not exist\n",argv[0]);
		}else{
			string bold = tput("bold");
			string normal = tput("sgr0");
			string clear = tput("clear");
			glocal string viewh;
			glocal OPTIONS options;
			mkdir ("/tmp/viewsel",0770);
			{
				const char *start = strrchr(argv[0],'/');
				if (start != NULL){
					start++;
				}else{
					start = argv[0];
				}
				string base = start;
				const char *pt = strstr(start,".scad");
				if (pt != NULL){
					base = string(start,pt-start);
				}
				glocal.viewh = "/tmp/viewsel/" + base + ".h";
			}
			ret = 0;
			while (1){
				glocal vector<VIEW> views = buildviews("--list",argv[0]);
				glocal vector<VIEW> tests = buildviews("--listtest",argv[0]);
				glocal vector<VIEW> prints = buildviews("--listprint",argv[0]);
				glocal vector<string> modes;
				glocal string view;
				if (!file_exist(glocal.viewh.c_str())){
					glocal.view = glocal.views[0].name;
					viewsel_create_header (glocal.viewh,argv[0],glocal.options.material,glocal.view,false);
				}else{
					<call loadfile>(glocal.viewh.c_str(),true);
					<f oneline>
						if (strncmp(line,"views=[\"",8)==0){
							const char *start = line +8;
							const char *end = strchr(start,'"');
							if (end != NULL){
								glocal.view = string(start,end-start);
							}
						}
						return 0;
					</f>
					</call>
				}
				glocal.modes = readmodes();
				printf ("%s",clear.c_str());
				printf ("Material %s%s%s\n",bold.c_str(),glocal.options.material.c_str(),normal.c_str());
				printf ("Mode    ");
				{
					unsigned width=0;
					for (unsigned i=0; i<glocal.modes.size(); i++){
						const char *mode = glocal.modes[i].c_str();
						int len = strlen(mode)+1;
						if (len + width > 70){
							printf ("\n        ");
							width = 0;
						}
						printf (" %s",mode);
						width += len;
					}
					printf ("\n\n");
				}
				vector<VIEW> &v = glocal.options.viewmode == VIEW_TEST
					? glocal.tests : (glocal.options.viewmode == VIEW_PRINT ? glocal.prints : glocal.views);
				static const char *tbmode[]={"Basic parts","Test views","Extra prints"};
				printf ("%s%s%s\n",bold.c_str(),tbmode[glocal.options.viewmode],normal.c_str());
				unsigned maxw = 0;
				for (unsigned i=0; i<v.size(); i++){
					unsigned len = v[i].name.size();
					if (len > maxw) maxw = len;
				}
				maxw += 5;
				for (unsigned i=0; i<v.size(); i++){
					if (v[i].name == glocal.view){
						printf ("%s%2u %-*s%s%s\n",bold.c_str(),i+1,maxw,glocal.view.c_str()
							,v[i].description.c_str(),normal.c_str());
					}else{
						printf ("%2u %-*s%s\n",i+1,maxw,v[i].name.c_str(),v[i].description.c_str());
					}
				}
				printf ("\n");
				printf ("S=number|name[,number|name,...]:xN,yN,wN,hN]\n");
				printf ("Choice [h,b,m,p,t,S,=S,!S]: ");
				char sel[100];
				fgets(sel,sizeof(sel),stdin);
				strip_end(sel);
				if (strcmp(sel,"q")==0 || strcmp(sel,"quit")==0){
					break;
				}else if (sel[0] == 'm' && sel[1] == ' ' && isalpha(sel[2])){
					glocal.options.material=sel+2;
					glocal.options.save();
				}else if (strcmp(sel,"basic")==0
					|| strcmp(sel,"b")==0){
					glocal.options.viewmode = VIEW_STD;
				}else if (strcmp(sel,"test")==0
					|| strcmp(sel,"t")==0){
					glocal.options.viewmode = VIEW_TEST;
				}else if (strcmp(sel,"print")==0
					|| strcmp(sel,"p")==0){
					glocal.options.viewmode = VIEW_PRINT;
				}else if (strcmp(sel,"help")==0
					|| strcmp(sel,"h")==0){
					printf ("\n"
						"basic,b selects the basic views\n"
						"print,p selects special views for printing\n"
						"test,t  selects test views\n"
						"m       selects a print material\n"
						"        m pla\n"
						"        m abs\n"
						"S       means a view, or a collection of views\n"
						"=S      displays the views, while enabling the vs_printing variable\n"
						"!S [opts] generates the gcode file\n"
						"\n"
						"// allviews view1[:xN,yN,wN,hN] ... // Description\n"
						"// testviews view1 ... // Description\n"
						"// printviews view1 ... // Description\n"
						"// viewopts view option ...\n"
						"// viewsopts option ...\n"
						);
					fgets(sel,sizeof(sel),stdin);
				}else if (sel[0] > ' '){
					bool error = false;
					string opt;
					bool printview=false;
					bool print = false;
					vector<string> views;
					const char *pt = NULL;
					vector<VIEW> allv;
					viewsel_append (allv,v);
					viewsel_append (allv,glocal.views);
					viewsel_append (allv,glocal.tests);
					viewsel_append (allv,glocal.prints);
					if (viewsel_parsecmd (sel,allv,views,opt,printview,print,pt)){
						error = true;
					}
					if (views.size()==0){
						printf ("\nNo view selected\n");
						error = true;
					}
					if (error){
						fgets(sel,sizeof(sel),stdin);
					}else{
						glocal const char *newv = views[0].c_str();
						auto words = str_splitline (pt,' ');
						if (!print){
							glocal.view = glocal.newv;
							viewsel_create_header(glocal.viewh,argv[0],glocal.options.material,views,opt,printview,words);
						}else{
							string cmd = "buildviews --slice --materialmode " + glocal.options.material;
							for (unsigned i=0; i<words.size(); i++){
								cmd += " --slicemode " + words[i];
							}
							cmd += string(" ") + argv[0] + string (" ");
							for (unsigned i=0; i<views.size(); i++){
								if (i > 0) cmd += string(",");
								cmd += views[i];
							}
							if (opt.size() > 0) cmd += string(":") + opt;
							printf ("cmd=%s\n",cmd.c_str());
							system (cmd.c_str());
							printf ("-------Done------\n");
							fgets(sel,sizeof(sel),stdin);
						}
					}
				}
			}
		}
		return ret;
	</f>
	</call>
	return glocal.ret;
}
</mod>