"use strict";

var cmn=require("../$common.js"),
    persist=require("node-persist"),
    crypto=require("crypto"),
    http=require("http"),
    https=require("https"),
    fs=require("fs"),
    URL=require("url"),
    child_process=require("child_process");

var moddir=null;

persist=persist.create({
	dir:cmn.persistdir+"/changes",
	continuous:false,
	interval:false
});
persist.initSync();

//urls: map(url => URLobject)
//url: String
//URLobject: {url, timeline: [[Date, hash, contents]]}
var urls=persist.getItemSync("urls");
if(!urls){
	urls={};
	persist.setItemSync("urls",urls);
} else {
	(function(){
		var url,i;
		for(url in urls){
			for(i=0;i<urls[url].timeline.length;i++){
				urls[url].timeline[i][0]=new Date(urls[url].timeline[i][0]);
			}
		}
	})();
}
//gsettings: {notify: null/{to: "email", interval: ms}}
var gsettings=persist.getItemSync("gsettings");
if(!gsettings){
	gsettings={notify: null};
	persist.setItemSync("gsettings",gsettings);
}

if(gsettings.notify){
	scheduleNotify();
}

var notifyTimeout=null;
function scheduleNotify(){
	if(notifyTimeout){
		console.log("WARNING: requesting notify schedule when already scheduled");
		return;
	}
	console.log("Scheduling notify in "+gsettings.notify.interval/1000+" seconds");
	notifyTimeout=setTimeout(notifyTimerFunction,gsettings.notify.interval);
}

function notifyTimerFunction(){
	if(!gsettings.notify){
		notifyTimeout=null;
		return;
	}
	notifyTimeout=setTimeout(notifyTimerFunction,gsettings.notify.interval);
	console.log("Performing notify");
	performNotify(gsettings.notify,function(err){
		if(err){
			console.log("notifyTimerFunction: error from (presumably) sendMail: ");
			console.log(err);
			return;
		}
		console.log("Performing cleanup");
		performCleanup();
	});
}


function URLobject(url){
	if(!(this instanceof URLobject))return new URLobject(url);
	this.url=url;
	this.timeline=[];
}

function fetch(method,url,data/*?*/,cb){
	var cbcalled=false;

	if(!cb){
		cb=data;
		data=undefined;
		if(!cb)throw new Error("No callback passed to fetch");
	}

	try {
		url=URL.parse(url);
	} catch(e){
		cb(-1,"URL parse failed: "+e.message);
		return;
	}

	var httpclass;
	switch(url.protocol){
		case "http:": httpclass=http; break;
		case "https:": httpclass=https; break;
		default:
			cb(-1,"Invalid URL protocol "+url.protocol);
			return;
	}

	url.method=method;

	var req=httpclass.request(url,function(res){
		var body="";
		res.on("data",function(data){
			body+=data;
		});
		res.on("end",function(){
			if(!cbcalled){
				if(res.statusCode==-1)cb(-1,"negative status code");
				else cb(res.statusCode,body);
			}
			cbcalled=true;
		});
		res.on("error",function(err){
			if(!cbcalled)cb(-1,"response error: "+err);
			cbcalled=true;
		});
	});
	req.on("error",function(err){
		if(!cbcalled)cb(-1,"request error: "+err);
		cbcalled=true;
	});
	if(data)req.write(data);
	req.end();
}

var refresh_persist_timeout=null;

function refreshURLs(cb){
	var hashes={};
	var i;
	var url;
	var nwaiting=0;
	for(url in urls){
		console.log("Fetching <"+url+">");
		nwaiting++;
		fetch("GET",url,function(url,status,body){
			nwaiting--;
			console.log("Got <"+url+">; status = "+status+(status==-1?" ("+body+")":""));
			var dosave=true;
			if(status==-1){
				hashes[url]=[new Date(),null,null];
				if(url=="https://futhark-lang.org/atom.xml"||
						url=="https://sigkill.dk/atom.xml"){
					console.log("TROELS IS WEER BEZIG");
					dosave=false;
				}
			} else {
				var hash=crypto.createHash("sha256");
				hash.update(body);
				var res=hash.digest("hex");
				hashes[url]=[new Date(),res,body];
				if(url=="http://www.rolandvdv.nl/M17/"&&
				   res=="6c09a3f77e8a1ce36ffdf1bf0cff8aa9bb5c17616ba8f31db31d8b5946245362"){
					console.log("ROLAND IS WEER BEZIG");
					dosave=false;
				}
			}

			if(dosave){
				if(!urls[url]){
					console.log("WARNING: url <"+url+"> from hashes not found in urls!");
				} else {
					//var last=urls[url].timeline[urls[url].timeline.length-1];
					//if(last==undefined||hashes[url][1]==null||hashes[url][1]!=last[1]){
						urls[url].timeline.push(hashes[url]);
					//}
				}
			}

			if(nwaiting==0&&cb)process.nextTick(cb);

			if(refresh_persist_timeout!=null)clearTimeout(refresh_persist_timeout);
			refresh_persist_timeout=setTimeout(function(){
				persist.setItemSync("urls",urls);
				console.log("(persisted after refresh)")
				refresh_persist_timeout=null;
			},2000);
		}.bind(null,url));
	}
}

function collectLastHashes(){
	var lasthashes={};
	var idx;
	for(var url in urls){
		if(urls[url].timeline.length==0){
			lasthashes[url]=null;
		} else {
			idx=urls[url].timeline.length-1;
			lasthashes[url]={
				hash: urls[url].timeline[idx][1],
				date: urls[url].timeline[idx][0]
			};
		}
	}
	return lasthashes;
}

function sendMail(tomails,body,cb){
	if(typeof tomails=="string")tomails=[tomails];
	else if(!Array.isArray(tomails)){
		throw new Error("tomails argument in sendMail not an array!");
	}
	var i;
	console.log("Mail to send: "+JSON.stringify(body));
	var proccounter=0;
	function decProcCounter(){
		proccounter--;
		if(proccounter==0){
			cb();
		}
	}
	var proc;
	for(i=0;i<tomails.length;i++){
		proc=child_process.spawn("sendmail",[tomails[i]],{stdio:["pipe",process.stdout,process.stderr]});
		proccounter++;
		console.log("sendmail process for <"+tomails[i]+"> started");
		proc.stdin.on("error",function(e){
			console.log(e);
			cb(e);
		});
		proc.stdin.write("To: "+tomails[i]+"\n"+body,function(proc,mailtarget){
			console.log("sendmail process for <"+mailtarget+"> write completed");
			proc.stdin.end();
		}.bind(this,proc,tomails[i]));
		proc.on("exit",function(mailtarget,code,signal){
			console.log("sendmail process for <"+mailtarget+"> exited with code "+code);
			decProcCounter();
		}.bind(this,tomails[i]));
		//process will linger till it's finished
	}
}

function constructMailBody(diffs){
	var body="From: changes <changes_module@tomsmeding.com>\n"+
	         "Subject: changes notification mail\n\n"+
	         "The changes module recorded some changes in watched webpages.\n"+
	         "The URLs and their old and new content hashes are shown below.\n\n";
	var i;
	for(i=0;i<diffs.length;i++){
		body+="- "+diffs[i].url+"\n"+
		      "  was: "+diffs[i].oldhash+" ("+diffs[i].olddate+")\n"+
		      "  now: "+diffs[i].newhash+" ("+diffs[i].newdate+")\n";
	}
	body+="\nCheck the diffs: https://tomsmeding.com/changes\n\n"+
	      "- webserver\n";
	return body;
}

function performNotify(settings,cb){
	var oldhashes=collectLastHashes();
	refreshURLs(function(){
		var newhashes=collectLastHashes();
		var diffs=[]; // [{url, oldhash, olddate, newhash, newdate}]
		for(var url in newhashes){
			if(!oldhashes[url])continue;
			if(newhashes[url].hash==oldhashes[url].hash)continue;
			diffs.push({
				url: url,
				oldhash: oldhashes[url].hash,
				olddate: oldhashes[url].date,
				newhash: newhashes[url].hash,
				newdate: newhashes[url].date
			});
		}
		console.log("performNotify: diffs = "+JSON.stringify(diffs));
		if(diffs.length!=0){
			console.log("performNotify: settings.to = "+JSON.stringify(settings.to));
			sendMail(settings.to,constructMailBody(diffs),cb);
		} else {
			cb();
		}
	});
}

function performCleanup(){
	for(var url in urls){
		/*
		//keep only the last hash and the last different hash intact
		//(if there is no different hash, delete everything but the last)
		if(urls[url].timeline.length<=2)continue;
		var i,lasthash,prevhash=null,prevhashidx=-1,tllen;
		tllen=urls[url].timeline.length;
		lasthash=urls[url].timeline[tllen-1][1];
		for(i=tllen-2;i>=0;i--){
			if(urls[url].timeline[i][1]!=lasthash){
				prevhash=urls[url].timeline[i][1];
				prevhashidx=i;
				break;
			}
		}
		if(prevhash==null){
			urls[url].timeline.splice(0,tllen-1);
		} else {
			urls[url].timeline.splice(prevhashidx+1,tllen-prevhashidx-2);
			urls[url].timeline.splice(0,prevhashidx);
		}
		*/

		//keep only the last record of a specific hash intact
		var i;
		for(i=urls[url].timeline.length-2;i>=0;i--){
			if(urls[url].timeline[i][1]==urls[url].timeline[i+1][1]){
				urls[url].timeline.splice(i,1);
			}
		}
	}
	persist.setItemSync("urls",urls);
}


module.exports=function(app,io,_moddir){
	moddir=_moddir;
	app.all(["/changes","/changes/*"],cmn.authgen());
	app.get("/changes",function(req,res){
		res.sendFile(moddir+"/changes.html");
	});
	app.get("/changes/urls",function(req,res){
		var list=[];
		var url;
		for(url in urls)list.push(url);
		res.json(list);
	});
	app.get("/changes/url",function(req,res){
		var url=req.query.url;
		if(!urls[url]){
			res.status(404);
			res.send("URL not found in watch list");
			return;
		}
		res.json(urls[url]);
	});
	app.post("/changes/url",function(req,res){
		var url=req.body;
		urls[url]=new URLobject(url);
		persist.setItemSync("urls",urls);
		// refreshURLs();
		res.send();
	});
	app.delete("/changes/url",function(req,res){
		var url=req.body;
		if(!urls[url]){
			res.status(404);
			res.send("URL not found in watch list");
			return;
		}
		delete urls[url];
		persist.setItemSync("urls",urls);
		res.send();
	});
	app.delete("/changes/url/history",function(req,res){
		var param;
		try {param=JSON.parse(req.body);}
		catch(e){
			res.status(400);
			res.send("Invalid JSON sent");
			return;
		}
		var url=param.url;
		var todate=new Date(param.todate);
		if(!urls[url]){
			res.status(404);
			res.send("URL not found in watch list");
			return;
		}
		if(todate.getTime()==NaN){
			res.status(400);
			res.send("Invalid time sent");
			return;
		}
		var tl=urls[url].timeline;
		var i;
		for(i=0;i<tl.length;i++){
			if(tl[i][0]<=todate){
				tl.splice(i,1);
				i--;
			}
		}
		persist.setItemSync("urls",urls);
		res.status(200);
		res.send();
	});
	app.post("/changes/refresh",function(req,res){
		refreshURLs();
		res.send();
	});
	app.post("/changes/diff",function(req,res){
		var param;
		try {param=JSON.parse(req.body);}
		catch(e){
			res.status(400);
			res.send("Invalid JSON sent");
			return;
		}
		var url=param.url;
		var newdate=new Date(param.newdate);
		var olddate=new Date(param.olddate);
		if(!urls[url]){
			res.status(404);
			res.send("URL not found in watch list");
			return;
		}
		if(newdate.getTime()==NaN||olddate.getTime()==NaN){
			res.status(400);
			res.send("Invalid time(s) sent");
			return;
		}
		if(newdate.getTime()==olddate.getTime()){
			res.status(400);
			res.send("Please select different records to diff");
			return;
		}
		var tl=urls[url].timeline;
		var newi=-1,oldi=-1,i;
		for(i=0;i<tl.length;i++){
			if(tl[i][0].getTime()==newdate.getTime()){
				newi=i;
			}
			if(tl[i][0].getTime()==olddate.getTime()){
				oldi=i;
			}
		}
		if(newi==-1||oldi==-1){
			res.status(404);
			res.send("Times not found in timeline for URL");
			return;
		}
		//res.send(tl[newi][1]+"\n"+tl[oldi][1]+"\n");
		fs.mkdtemp("/tmp/changes-diff-tmp-",function(err,folder){
			if(err){
				console.log(err);
				res.status(500);
				res.send();
				return;
			}
			function cleanup() {
				try { fs.unlinkSync(folder+"/old.html"); } catch(e) { console.log(e); }
				try { fs.unlinkSync(folder+"/new.html"); } catch(e) { console.log(e); }
				try { fs.unlinkSync(folder+"/diff.txt"); } catch(e) { console.log(e); }
				try { fs.rmdirSync(folder);              } catch(e) { console.log(e); }
			}

			var counter=0;
			var fscb=function(err){
				if(err){
					cleanup();
					console.log(err);
					res.status(500);
					res.send();
					return;
				}
				counter++;
				if(counter<2)return;

				var proc=child_process.spawn(
					"diff",
					[folder+"/old.html",folder+"/new.html"],
					{stdio:[process.stdin,fs.openSync(folder+"/diff.txt","w"),process.stderr]});

				proc.on("exit",function(code,signal){
					var stream=fs.createReadStream(folder+"/diff.txt");
					stream.pipe(res);
					stream.on("end",cleanup);
				});
			};
			fs.writeFile(folder+"/old.html",tl[oldi][2],fscb);
			fs.writeFile(folder+"/new.html",tl[newi][2],fscb);
		});
	});
};