module cn.kuehne.dstress.log;

private import std.string;
private import std.conv;
private import std.stdio;
private import std.stream;
private import std.file;
private import std.c.stdlib;
private import std.date;

static char[][] TORTURE_FLAGS = [
	/* 0 args */
	"",

	/* 1 args */
	"-g",
	"-inline",
	"-fPIC",
	"-O",
	"-release",

	/* 2 args */
	"-g -inline",
	"-g -fPIC",
	"-g -O",
	"-g -release",
	"-inline -fPIC",
	"-inline -O",
	"-inline -release",
	"-fPIC -O",
	"-fPIC -release",
	"-O -release",

	/* 3 args */
	"-g -inline -fPIC",
	"-g -inline -O",
	"-g -inline -release",
	"-g -fPIC -O",
	"-g -fPIC -release",
	"-g -O -release",
	"-inline -fPIC -O",
	"-inline -fPIC -release",
	"-inline -O -release",
	"-fPIC -O -release",

	/* 4 args */
	"-g -inline -fPIC -O",
	"-g -inline -fPIC -release",
	"-g -fPIC -O -release",
	"-inline -fPIC -O -release",

	/* 5 args */
	"-g -inline -fPIC -O -release",

	/* 4 args - ommitted */
	"-g -inline -O -release"
];

enum Result{
	UNTESTED	= 0,
	PASS		= 1 << 2,
	XFAIL		= 2 << 2,
	XPASS		= 3 << 2,
	FAIL		= 4 << 2,
	ERROR		= 5 << 2,
	BASE_MASK	= 7 << 2,

	EXT_MASK	= 3,
	BAD_MSG		= 1,
	BAD_GDB		= 2,
	
	MAX		= BAD_GDB + BASE_MASK
}

char[] toString(Result r){
	switch(r & Result.BASE_MASK){
		case Result.PASS: return "PASS";
		case Result.XPASS: return "XPASS";
		case Result.FAIL: return "FAIL";
		case Result.XFAIL: return "XFAIL";
		case Result.ERROR: return "ERROR";
		case Result.UNTESTED: return "UNTESTED";
		default:
			break;
	}
	throw new Exception(format("unhandled Result value %s", cast(int)r));
}

char[] dateString(){
	static char[] date;
	if(date is null){
		auto time = getUTCtime();
		auto year = YearFromTime(time);
		auto month = MonthFromTime(time);
		auto day = DateFromTime(time);
		date = format("%d-%02d-%02d", year, month+1, day); 
	}
	return date;
}

char[][] unique(char[][] a){
	char[][] b = a.sort;
	char[][] back;

	back ~= b[0];

	size_t ii=0;
	for(size_t i=0; i<b.length; i++){
		if(back[ii]!=b[i]){
			back~=b[i];
			ii++;
		}
	}

	return back;	
}

private{
	version(Windows){
		import std.c.windows.windows;
		extern(Windows) BOOL GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime);
	}else version(linux){
		import std.c.linux.linux;
		version = Unix;
	}else version(Unix){
		import std.c.unix.unix;
	}else{
		static assert(0);
	}

	alias ulong FStime;

	FStime getFStime(char[] fileName){
		version(Windows){
			HANDLE h;
		
			if (useWfuncs){
				wchar* namez = std.utf.toUTF16z(fileName);
				h = CreateFileW(namez,GENERIC_WRITE,0,null,OPEN_ALWAYS,
					FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null);
			}else{
				char* namez = toMBSz(fileName);
				h = CreateFileA(namez,GENERIC_WRITE,0,null,OPEN_ALWAYS,
				FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null);
			}

			if (h == INVALID_HANDLE_VALUE)
				goto err;

			FILETIME creationTime;
			FILETIME accessTime;
			FILETIME writeTime;
		
			BOOL b = GetFileTime(h, &creationTime, &accessTime, &writeTime);
			if(b==1){
				long modA = writeTime.dwLowDateTime;
				long modB = writeTime.dwHighDateTime;
				return modA  | (modB << (writeTime.dwHighDateTime.sizeof*8));
			}

err:
			CloseHandle(h);
			throw new Exception("failed to query file modification : "~fileName);
		}else version(Unix){
			char* namez = toStringz(fileName);
			struct_stat statbuf;
		
			if(stat(namez, &statbuf)){
				throw new FileException(fileName, getErrno());
			}

			return statbuf.st_mtime;
		}else{
			static assert(0);
		}
	}
}

char[] cleanFileName(char[] file){
	char[] back;
	bool hadSep;

	foreach(char c; file){
		if(c == '/' || c == '\\'){
			if(!hadSep){
				back ~= '/';
				hadSep = true;
			}
		}else{
			back ~= c;
			hadSep = false;
		}
	}

	size_t start = 0;
	while(back[start] <= ' ' && start < back.length){
		start++;
	}

	size_t end = back.length-1;
	while(back[end] <= ' ' && end >= start){
		end--;
	}

	back = back[start .. end+1];

	return back;
}

abstract class Test{
	char[] name;
	char[] file;

	abstract Result condensed();

	this(char[] file){
		this.file = file;

		int start = rfind(file, "/");
		if(start<0){
			start = 0;
		}else{
			start += 1;
		}
		
		int end = rfind(file, ".");
		if(end < start){
			end = file.length;
		}

		name = file[start .. end];
	}
}

class TortureTest : Test{
	Result[] r;

	Result condensed(){
		Result back;
		foreach(Result res; r){
			if(res > back){
				back = res;
			}
		}

		return back;
	}

	this(char[] file){
		super(file);
		r.length = TORTURE_FLAGS.length;
	}

	this(char[] file, Result[] result){
		if(result.length != TORTURE_FLAGS.length){
			throw new Exception(format("expected %s results but got %s (%s)", TORTURE_FLAGS.length, result.length, file));
		}

		super(file);
		r = result.dup;
	}
}

class Log{
	TortureTest[char[]] torture;

	char[] id;

	this(char[] id){
		this.id = id;
	}

	Regression[] findGlobalRegressions(Log[] logs){
		Regression[] back;

		if(logs.length < 1){
			return back;
		}

		foreach(TortureTest currentTest; torture.values){
			bool hadOldData = false;
			Result oldResults[];
			oldResults.length = TORTURE_FLAGS.length;
			oldResults[] = Result.MAX;

			foreach(Log l; logs){
				TortureTest* test = currentTest.file in l.torture;
				if(test !is null){
					hadOldData = true;
					foreach(size_t i, Result r; test.r){
						if(r != Result.UNTESTED && r < oldResults[i]){
							oldResults[i] = r;
						}
					}
				}
			}

			if(hadOldData){
				foreach(size_t i, Result r; oldResults){
					if((currentTest.r[i] != Result.UNTESTED) && (r != Result.MAX) && (currentTest.r[i] > r)){
						back ~= new Regression(currentTest.name, currentTest.file, r, currentTest.r[i], TORTURE_FLAGS[i]);
					}
				}
			}
		}
		return back;
	}

	Regression[] findRegressions(Log oldLog){
		Regression[] back;
		
		foreach(TortureTest t; torture.values){
			TortureTest* oldT = t.file in oldLog.torture;

			if(oldT !is null){
				foreach(size_t i, Result r; t.r){
					if(oldT.r[i] < r && oldT.r[i]){
						back ~= new Regression(t.name, t.file, oldT.r[i], r, TORTURE_FLAGS[i]); 
					}
				}
			}
		}

		return back;
	}

	char[][] genUpdateList(char[] testRoot){
		char[][] updateList;
		const char[][] statusList = ["compile", "nocompile", "run", "norun"];
		char[] status;

		void list(char[] path){
			if(isdir(path)){
				foreach(char[] entry; listdir(path)){
					if(entry.length>0 && entry[0] != '.' && entry[0] != '~'){
						list(path~std.path.sep~entry);
					}
				}
			}else if(isfile(path)){
				char[] file = path[testRoot.length + std.path.sep.length .. $];
				if(!(file in torture)){
					char[] output = "dstress torture-" ~ status ~ " " ~ file;
					updateList ~= output;
				}
			}	
		}
		
		foreach(char[] s; statusList){
			status = s;
			list(testRoot ~ std.path.sep ~ s);
		}

		return updateList;
	}

	void dropBogusResults(FStime recordTime, char[] testRoot){
		uint totalCount = torture.length; 
		
		char[][] sourcesTorture = torture.keys;
		foreach(char[] source; sourcesTorture){
			if(find(source, "complex/") < 0){
				try{
					FStime caseTime = getFStime(testRoot~std.path.sep~source);
					if(caseTime > recordTime){
						debug(drop) fwritefln(stderr, "dropped: %s", source);
						torture.remove(source);
					}
				}catch(Exception e){
					debug(drop) fwritefln(stderr, "dropped: %s", source);
					torture.remove(source);
				}
			}
			// asm-filter
			int i = find(source, "asm_p");
			if(i >= 0){
				torture.remove(source);
			}
		}
		torture.rehash;
		
		writefln("dropped %s outdated tests (%s remaining)", totalCount - torture.length, torture.length); 
	}

	
	bool add(char[] line){
		const char[] SUB = "Torture-Sub-";
		const char[] TORTURE = "Torture:";

		line = strip(line);
		int id = -1;
		Result r = Result.UNTESTED;

		if(line.length > SUB.length && line[0 .. SUB.length] == SUB){
			line = line[SUB.length .. $];
			id = 0;
			while(line[id] >= '0' && line[id] <= '9'){
				id++;
			}
			int start = id;
			id = std.conv.toUint(line[0 .. id]);

			while(line[start] != '-'){
				start++;
			}
			line = line[start+1 .. $];
		}

		char[][] token = split(line);
		if(token.length < 2){
			return false;
		}
		char[] file = strip(token[1]);

		switch(token[0]){
			case "PASS:":
				r = Result.PASS; break;
			case "FAIL:":
				r = Result.FAIL; break;
			case "XPASS:":
				r = Result.XPASS; break;
			case "XFAIL:":
				r = Result.XFAIL; break;
			case "ERROR:":
				r = Result.ERROR; break;
			default:{
				if(token[0] == TORTURE){
					throw new Exception("not yet handled: "~line);
				}else if(id > -1){
					throw new Exception(format("bug in SUB line: (%s) %s", id, line));
				}
			}
		}

		if(r != Result.UNTESTED){
			if(std.string.find(line, "bad error message") > -1){
				r |= Result.BAD_MSG;	
			}
			if(std.string.find(line, "bad debugger message") > -1){
				r |= Result.BAD_MSG;	
			}
			
			file = cleanFileName(file);
			
			if(id >= 0){
				// update sub
				id--;
		
				TortureTest* test = file in torture;

				if(test is null){
					TortureTest t = new TortureTest(file);
					torture[file] = t;
					t.r[id] = r;
				}else{
					if(test.r[id] != Result.UNTESTED){
						test.r[] = Result.UNTESTED;
					}
					test.r[id] = r;
				}
			}
			return true;
		}
		return false;
	}
}

class Regression{
	Result before;
	Result after;
	char[] file;
	char[] name;
	char[] extInfo;

	this(char[] name, char[] file, Result oldR, Result newR, char[] addonInfo=null){
		this.file = file;
		this.name = name;
		before = oldR;
		after = newR;
		extInfo = addonInfo;
	}

	char[] toString(){
		char[] back = .toString(before) ~" -> "~.toString(after)~": "~file;
		if(extInfo.length > 0){
			back ~= " ("~extInfo~")";
		}
		return back;
	}
}

class Report{
	char[] root;
	Log[] log;
	static const char[] header =
		"<th>&#160;</th><th>-g</th><th>-inline</th>"
		"<th>-fPIC</th><th>-O</th><th>-release</th>"
		"<th>-g -inline</th><th>-g -fPIC</th><th>-g -O</th>"
		"<th>-g -release</th><th>-inline -fPIC</th>"
		"<th>-inline -O</th><th>-inline -release</th>"
		"<th>-fPIC -O</th><th>-fPIC -release</th>"
		"<th>-O -release</th><th>-g -inline -fPIC</th>"
		"<th>-g -inline -O</th><th>-g -inline -release</th>"
		"<th>-g -fPIC -O</th><th>-g -fPIC -release</th>"
		"<th>-g -O -release</th><th>-inline -fPIC -O</th>"
		"<th>-inline -fPIC -release</th><th>-inline -O -release</th>"
		"<th>-fPIC -O -release</th><th>-g -inline -fPIC -O</th>"
		"<th>-g -inline -fPIC -release</th>"
		"<th>-g -fPIC -O -release</th>"
		"<th>-inline -fPIC -O -release</th>"
		"<th>-g -inline -fPIC -O -release</th>"
		"<th>-g -inline -O -release</th>";
	
	this(char[] root, Log[] log){
		this.root = root;
		this.log = log;
	}

	void toHtml(OutputStream summary, OutputStream[] cases, bool[] hotspot){
		
		if(cases.length != log.length || cases.length != hotspot.length){
			throw new Exception("unexpected argument length");
		}
		foreach(size_t i, Log l; log){
			toHtml(l, cases[i]);
		}
		toHtmlSummary(summary, hotspot);
	}

	static char[] cleanFileName(char[] name){
		int i = rfind(name, "_");
		if(i > -1){
			name = name[i+1 .. $];
		}
		i = rfind(name, ".");
		if(i > -1){
			name = name[0 .. i];
		}
		return name;
	}
	
	static char[] streamLine(uint[] stats){
		char[] buffer;
		foreach(uint i; stats){
			buffer ~= "<td>"~std.string.toString(i)~"</td>";
		}
		return buffer;
	}

	static void toHtml(Log log, OutputStream stream){
		char[] cleanName = cleanFileName(log.id);
		{ // header
			char[] name = toupper(cleanName);
		
			stream.writeLine("<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>");
			stream.writeLine("<html xmlns='http://www.w3.org/1999/xhtml' lang='en' xml:lang='en'>");

			stream.writeLine("<head><title>DStress - Torture: "~name~"</title><link rel='stylesheet' type='text/css' href='formate.css' /><meta name='author' content='Thomas K&#252;hne' /><meta name='date' content='" ~ dateString() ~ "' /><link rel='shortcut icon' href='data:image/gif;base64,R0lGODlhEAAQAKEAALMfEuWoLv///7MfEiH5BAEKAAMALAAAAAAQABAAAAIpnI95wN06nARqyvSQM6Gz+g3dOGofiabqygYmNYbv/FKLld04aEG+UgAAOw==' type='image/gif' /></head>");
			stream.writeLine("<body><center><h1>DStress - Torture: "~name~"</h1></center><center><small>by Thomas K&#252;hne &lt;<a href='mailto:thomas@kuehne.cn'>thomas@kuehne.cn</a>&gt;</small></center>");
			stream.writeLine("<h2><a name='note' id='note'></a>Note</h2><blockquote>A detailed description of the testing and the used symbols can be found on the <a href='./dstress.html'>main page</a>.</blockquote>");
		}
		
		{ // stats
			stream.writeLine("<h2><a name='summary' id='summary'></a>Summary</h2>");
			uint[][] stats;
			stats.length = 6;
			foreach(inout uint[] array; stats){
				array.length = TORTURE_FLAGS.length;
			}

			foreach(TortureTest t; log.torture){
				foreach(int i, Result r; t.r){
					stats[r >> 2][i]++;
				}
			}

			
			{ // total
				uint total = 0;
				
				foreach(uint[] cases; stats){
					total += cases[0];
				}

				uint config = 0;
				foreach(uint[] a; stats[1 .. $]){
					foreach(uint b; a){
						config += b;
					}
				}
				
				stream.writeLine(format("<blockquote><dl><dt><strong>test cases:</strong></dt><dd>%d</dd><dt><strong>tested configurations:</strong></dt><dd>%d</dd></dl></blockquote>", total, config));
			}


			stream.writeLine("<table border='1' summary='nummeric summary of the test results'>");
			stream.writeLine("\t<tr><td>&#160;</td>"~header~"</tr>");
			stream.writeLine("\t<tr class='" ~ cast(char)('A'+Result.PASS)~"'><th>PASS</th>" ~ streamLine(stats[Result.PASS >> 2])~"</tr>");
			stream.writeLine("\t<tr class='" ~ cast(char)('A'+Result.XFAIL)~"'><th>XFAIL</th>" ~ streamLine(stats[Result.XFAIL >> 2])~"</tr>");
			stream.writeLine("\t<tr class='" ~ cast(char)('A'+Result.XPASS)~"'><th>XPASS</th>" ~ streamLine(stats[Result.XPASS >> 2])~"</tr>");
			stream.writeLine("\t<tr class='" ~ cast(char)('A'+Result.FAIL)~"'><th>FAIL</th>" ~ streamLine(stats[Result.FAIL >> 2])~"</tr>");
			stream.writeLine("\t<tr class='" ~ cast(char)('A'+Result.ERROR)~"'><th>ERROR</th>" ~ streamLine(stats[Result.ERROR >> 2])~"</tr>");
			stream.writeLine("\t<tr class='" ~ cast(char)('A'+Result.UNTESTED)~"'><th>untested</th>" ~ streamLine(stats[Result.UNTESTED >> 2])~"</tr>");
			stream.writeLine("</table>");
		}

		{ // details
			stream.writeLine("<h2><a name='details' id='details'></a>Details</h2>");
			stream.writeLine("<table border='1' summary='detailed listing of all test cases with unexpected results'>");
			stream.writeLine("<tr><td>&#160;</td>"~header~"</tr>");
			
			char[][] keys;
			{
				char[][char[]] k;
				foreach(char[] org; log.torture.keys){
					char[] z = org;
					int i = rfind(z, "/");
					if(i > -1){
						z = z[i+1 .. $];
					}
					i = rfind(z, ".");
					if(i > -1){
						z = z[0 .. i];
					}
					if(z in k && find(org, "complex") < 0){
						throw new Exception("dublicate key "~org);
					}
					k[z] = org;
				}

				foreach(char[] x; k.keys.sort){
					keys ~= k[x];	
				}

			}
			foreach(char[] key; keys){
				TortureTest t = log.torture[key];
				Result plainR = t.condensed();

				if(plainR == Result.PASS
					|| plainR == Result.XFAIL
					|| plainR == Result.UNTESTED)
				{
					continue;
				}else{
					char[] name = replace(t.name, "_", " ");
					char[] src = t.file;
					if(find(src,"complex/") != -1){
						src = src[0 .. rfind(src, "/")];
					}
					char[] back = "<tr><th><a href=\"../"~src~"\" id='"~t.name~"'>"~name~"</a></th>";
					foreach(Result r; t.r){
						back ~= "<td class='" ~ cast(char)(r+'A') ~ "'>";
						if(r == Result.UNTESTED){
							back ~= "-";
						}else{
							try{
								back ~= .toString(r & Result.BASE_MASK);
							}catch(Exception e){
								throw new Exception(t.toString()~" ["~e.toString()~"]");
							}
						}
						back ~= "</td>";
					}
					stream.writeLine(back ~ "</tr>");
				}
			}

			stream.writeLine("<tr><td>&#160;</td>"~header~"</tr>");
			stream.writeLine("</table>");
		}
		
		{ // footer
			stream.writeLine("<div><br /><br /><hr /><a href='http://dstress.kuehne.cn/www/"~cleanName~".html'>http://dstress.kuehne.cn/www/"~cleanName~".html</a>&#160; &#160;" ~ dateString() ~ "</div>");
			stream.writeLine("<center><a href='http://developer.berlios.de'><img src='http://developer.berlios.de/bslogo.php?group_id=2732' width='124' height='32' border='0' alt='BerliOS Logo' /></a></center>");

			stream.writeLine("</body></html>");
		}
	}

	void toHtmlSummary(OutputStream stream, bool[] hotspot){
		if(hotspot.length != log.length){
			throw new Exception("illegal hotspot length");
		}

		char[][] names;
		
		foreach(Log l; log){
			names ~= l.torture.keys;
		}

		uint[][] stats;
		stats.length = 6;
		foreach(inout uint[] array; stats){
			array.length = log.length;
		}
		

		char[][char[]] keys;
		{
			foreach(char[] org; unique(names)){
				char[] z = org;
				int i = rfind(z, "/");
				if(i > -1){
					z = z[i+1 .. $];
				}
				i = rfind(z, ".");
				if(i > -1){
					z = z[0 .. i];
				}
				if(z in keys && -1 == find(org, "complex/")){
					throw new Exception("dublicate key "~org);
				}
				keys[z] = org;
			}

		}

		{ // total
			uint total = keys.keys.length;
			for(size_t i = 0; i < stats[0].length; i++){
				stats[0][i] = total;
			}
		}

		char[][] badLines;
		foreach(char[] name; keys.keys.sort){
			char[] file = keys[name];
			Result[] result = new Result[log.length];
			bool isBadLine;
			foreach(size_t i, Log l; log){
				auto t = file in l.torture;		

				if(t){
					Result r = t.condensed();
					result[i] = r;

					if(r != Result.UNTESTED){
						stats[result[i] >> 2][i]++;
						stats[0][i]--;
						if(hotspot[i] && r>= Result.XPASS){
							isBadLine = true;
						}
					}
				}

			}
			
			if(isBadLine){
				char[] cleanName = replace(name, "_", " ");
				char[] back = "<tr><th><a href=\"../"~file~"\" id='"~name~"'>"~cleanName~"</a></th>";
				foreach(Result r; result){
					back ~= "<td class='" ~ cast(char)(r+'A') ~ "'>";
					if(r == Result.UNTESTED){
						back ~= "-";
					}else{
						try{
							back ~= .toString(r & Result.BASE_MASK);
						}catch(Exception e){
							throw new Exception("name:" ~name~" ["~e.toString()~"]");
						}
					}
					back ~= "</td>";
				}
				badLines ~= back ~ "</tr>";
			}
		}


		// output
		stream.writeLine("<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>");
		stream.writeLine("<html xmlns='http://www.w3.org/1999/xhtml'>");
		stream.writeLine("<head><title>DStress Report</title><link rel='stylesheet' type='text/css' href='formate.css' /><meta name='author' content='Thomas K&#252;hne' /><meta name='date' content='"~dateString()~"' /></head>");
		stream.writeLine("<body><center><h1>DStress Report</h1></center>");
		stream.writeLine("<h2><a name='note' id='note'></a>Note</h2>");
		stream.writeLine("<blockquote><p>A detailed description of the testing and the used symbols can be found on the <a href='./dstress.html'>main page</a>.</p></blockquote>");
		stream.writeLine("<h2><a name='summary' id='summary'></a>Summary</h2>");

		stream.writeLine("<table border='1' summary='nummeric summary of the test results'>");
		char[] versionHeader = "<tr><td>&#160;</td>";
		{ // version header
			foreach(Log l; log){
				char[] name = l.id;
				int i = rfind(name, "/");
				if(i > -1){
					name = name[i+1 .. $];
				}
				i = rfind(name, ".log");
				if(i + ".log".length == name.length){
					name = name[0 .. i];
				}
				versionHeader ~= "<th><a href='./" ~ cleanFileName(l.id) ~ ".html'>"~replace(name, "_", " ")~"</a></th>";
			}
			versionHeader ~= "</tr>";
		}
		
		stream.writeLine("\t<tr><td>&#160;</td>"
			"<th class='" ~ cast(char)('A'+Result.PASS)~"'>PASS</th>"
			"<th class='" ~ cast(char)('A'+Result.XFAIL)~"'>XFAIL</th>"
			"<th class='" ~ cast(char)('A'+Result.XPASS)~"'>XPASS</th>"
			"<th class='" ~ cast(char)('A'+Result.FAIL)~"'>FAIL</th>"
			"<th class='" ~ cast(char)('A'+Result.ERROR)~"'>ERROR</th>"
			"<th class='" ~ cast(char)('A'+Result.UNTESTED)~"'>UNTESTED</th></tr>");
		foreach(size_t j, Log l; log){
			char[] row ="\t<tr>";
			char[] name = l.id;
			int i = rfind(name, "/");
			if(i > -1){
				name = name[i+1 .. $];
			}
			i = rfind(name, ".log");
			if(i + ".log".length == name.length){
				name = name[0 .. i];
			}
			row ~= "<th><a href='./" ~ cleanFileName(l.id) ~ ".html'>"~replace(name, "_", " ")~"</a></th>";
			row ~= "<td class='" ~ cast(char)('A'+Result.PASS)~"'>" ~ std.string.toString(stats[Result.PASS >> 2][j]) ~"</td>";
			row ~= "<td class='" ~ cast(char)('A'+Result.XFAIL)~"'>" ~ std.string.toString(stats[Result.XFAIL >> 2][j]) ~"</td>";
			row ~= "<td class='" ~ cast(char)('A'+Result.XPASS)~"'>" ~ std.string.toString(stats[Result.XPASS >> 2][j]) ~"</td>";
			row ~= "<td class='" ~ cast(char)('A'+Result.FAIL)~"'>" ~ std.string.toString(stats[Result.FAIL >> 2][j]) ~"</td>";
			row ~= "<td class='" ~ cast(char)('A'+Result.ERROR)~"'>" ~ std.string.toString(stats[Result.ERROR >> 2][j]) ~"</td>";
			row ~= "<td class='" ~ cast(char)('A'+Result.UNTESTED)~"'>" ~ std.string.toString(stats[Result.UNTESTED >> 2][j]) ~"</td>";
			stream.writeLine(row ~ "</tr>");
		}
		stream.writeLine("</table>");

		stream.writeLine("<h2><a name='details' id='details'></a>Details</h2>");
		stream.writeLine("<table border='1'>");
		stream.writeLine(versionHeader);
		foreach(char[] line; badLines){
			stream.writeLine(line);
		}
		stream.writeLine(versionHeader);
		stream.writeLine("</table>");
		
		stream.writeLine("<div><br /><br /><hr /><a href='http://dstress.kuehne.cn/www/results.html'>http://dstress.kuehne.cn/www/results.html</a>&#160; &#160;"~dateString()~"</div>");

		stream.writeLine("<!-- Start of StatCounter Code -->");
		stream.writeLine("<script type='text/javascript'><!-- var sc_project=1337754; var sc_invisible=1; var sc_partition=12; var sc_security=\"a4a998fe\"; var sc_remove_link=1; //--> </script>");
		stream.writeLine("<script type='text/javascript' src='http://www.statcounter.com/counter/counter_xhtml.js'></script><noscript><div class='statcounter'><img src='http://c13.statcounter.com/counter.php?sc_project=1337754&amp;amp;java=0&amp;amp;security=a4a998fe&amp;amp;invisible=1' class='statcounter' alt='counter' /></div></noscript>");
		stream.writeLine("<!-- End of StatCounter Code -->");

		stream.writeLine("</body></html>");
	}
}

int main(char[][] args){

	if(args.length < 4){
		fwritefln(stderr, "%s <command> <root> <log.1> [<log.2> ...]", args[0]);
		fwritefln(stderr, "known commands: genUpdateList findRegressions genReport");
		return 1;
	}
	
	
	char[] command = args[1];
	char[] root = args[2];
	if(root.length < 1){
		root = ".";
	}
	debug fwritefln(stderr, "command: %s", command);
	debug fwritefln(stderr, "root: %s", root);

	Report report = new Report(root, null);
	bool[] hotspot;

	switch(command){
		case "genUpdateList", "findRegressions", "genReport": break;
		default:{
			fwritefln(stderr, "unknown command: %s", command);
			return -1;
		}
	}

	foreach(size_t id, char[] file; args[3 .. $]){
		if(file.length > "--".length && file[0 .. 2] == "--"){
			file = file[2..$];
			hotspot ~= true;
		}else{
			hotspot ~= false;
		}

		writefln("parsing: %s", file);
		FStime logTime  = getFStime(file);
		debug fwritefln(stderr, "sourceTime: %s", logTime);

		Log l= new Log(file);
		Stream source = new BufferedFile(file, FileMode.In);
		while(!source.eof()){
			l.add(source.readLine());
		}
		
		l.dropBogusResults(logTime, root);

		report.log ~= l;
	}

	switch(command){
		case "genUpdateList":{
			foreach(Log l; report.log){
				char[][] update = l.genUpdateList(root);
				writefln("%s updates required (%s still up to date)", update.length, l.torture.length);

				char[] updateFile = l.id ~ ".update";
				try{std.file.remove(updateFile);}catch{}

				if(update.length){
					File f = new File(updateFile, FileMode.OutNew);
					foreach(char[] line; update){
						f.writeLine(line);
					}
					f.close();
				}
			}
			break;
		}case "findRegressions":{
			foreach(size_t i, Log newLog; report.log[1..$]){
				Regression[] newReg = newLog.findRegressions(report.log[i]);
				writefln("identified %s new regressions for %s", newReg.length, newLog.id);
			
				Regression[] oldReg;
				{
					Regression[] oldRegT = newLog.findGlobalRegressions(report.log[0 .. i]);
					foreach(Regression a; oldRegT){
						foreach(Regression b; newReg){
							if(a.file == b.file && (!a.extInfo || a.extInfo == b.extInfo)){
								goto handled;
							}
						}

						oldReg ~= a;
					handled: {}
					}
				}
				
				writefln("identified %s old regressions for %s", oldReg.length, newLog.id);

				char[] regressionFile = newLog.id ~ ".regression";
				try{std.file.remove(regressionFile);}catch{}
				
				if(newReg.length + oldReg.length){
					File f = new File(regressionFile, FileMode.OutNew);

					if(newReg.length){
						f.writeLine(format("%s new regressions", newReg.length));
						foreach(Regression r; newReg){
							f.writeLine(r.toString());
						}
					}

					if(oldReg.length){
						if(newReg.length){
							f.writeLine("");
						}
						f.writeLine(format("%s old regressions", oldReg.length));
						foreach(Regression r; oldReg){
							f.writeLine(r.toString());
						}
					}
					
					f.close();
				}
			}
			break;	
		}case "genReport":{
			OutputStream[] html;
			OutputStream o = new File("./www/results.html", FileMode.OutNew);
			foreach(Log l; report.log){
				html ~= new File("./www/"~Report.cleanFileName(l.id)~".html", FileMode.OutNew);
			}

			report.toHtml(o, html, hotspot);
			
			o.close();
			foreach(OutputStream stream; html){
				stream.close();
			}

			break;
		}default:{
			fwritefln(stderr, "unknown command: %s", command);
			return -1;
		}
	}
	
	return 0;
}