var refreshTimeout=120000;

// Initialise data ready flags
var almanacReady=0;
var CRReady =0;
var ECRReady=0;
var HCRReady=0;
var DCRReady=0;
var hr24Ready=0;
var day7Ready=0;
var solarCurrentReady=0;
var solarTodayReady=0;
var solarDayHistoryReady=0;
var solarMonthlyAveragesReady=0;
var dataReady=0;

// Temporary variables
var lines24hr;
var lines7day;

// All weather variables
var stationName;			// Name from clientraw
var time;				// Time of last update from clientraw

var hourOutTemp = new Array(60);	// Last 60 minutes temp
var hourBaro = new Array(60);		// Last 60 minutes baro
var hourMaxWindGust;			// Last 60 minutes max Wind Gust

var dayOutTemp = [];		// Last 24 hours temp
var dayOutWind = [];		// Last 24 hours wind
var dayBaro = [];

var weekOutTemp = [];
var weekOutWind = [];

var solarTodayDate = [];
var solarTodayWatts = [];
var solarTodayTotal = [];
var solarMax;
var solarDailyHistory = [];
var solarMonthlyAverages = [];

var actualOutTemp;			// Current outside temperature
var actualWind;				// Current wind
var actualOutHumidity;			// Current outside humidity
var actualBaro;				// Current pressure reading

var dailyMaxWindGust;			// Daily Maximum Wind Gust
var dailyMinOutTemp;			// Daily Minimum outside temperature

var dailyMaxOutTemp;			// Daily maximum outside temperature

var ytdMaxOutTemp;
var ytdMaxOutTempTimeStamp;
var ytdMinOutTemp;
var ytdMinOutTempTimeStamp;

var atMaxOutTemp;
var atMaxOutTempTimeStamp;
var atMinOutTemp;
var atMinOutTempTimeStamp;

var mMaxOutTemp;
var mMaxOutTempTimeStamp;
var mMinOutTemp;
var mMinOutTempTimeStamp;

var sunrise;				// Local Sunrise
var sunset;				// Local Sunset
var dawn;				// Local Dawn
var dusk;				// Local Dusk
var solarSunriseTime;
var solarSunsetTime;

var solarDate;
var solarTime;
var solarWatts;

var crExtraTimestamp = [];

function parseClientRaw(rawData){

	var clientRaw = rawData.split(" ");
	if(clientRaw[0]!='12345')
	{
	 getCR();
	}
	else
	{
		var station_time = clientRaw[32].split("-");
        	time = station_time[station_time.length - 1];
        	stationName = station_time[0];
        	actualOutTemp = clientRaw[4];
		actualOutHumidity=clientRaw[5];
		dailyMinOutTemp=clientRaw[47];
		dailyMaxOutTemp=clientRaw[46];
        	actualOutHumidity = clientRaw[5] ;
        	actualBaro = clientRaw[6];
        	actualWind = Math.round(clientRaw[1]*11.5)/10;
        	dailyMaxWindGust = Math.round(clientRaw[71]*11.5)/10;
		hourMaxWindGust = Math.round(clientRaw[133]*11.5)/10;		
		CRReady=1;
}
}

function parseClientRawExtra(rawECR){
	var clientRawExtra = rawECR.split(" ");
	if(clientRawExtra[0]!='12345')
	{
	getECR();
	}
	else
	{
	

	ytdMaxOutTemp=clientRawExtra[187];
	ytdMaxOutTempTimeStamp=clientRawExtra[190] + "/" + clientRawExtra[191]+ "/" + clientRawExtra[192] + " " + clientRawExtra[188] + ":" + clientRawExtra[189] ;
	ytdMinOutTemp=clientRawExtra[193];
	ytdMinOutTempTimeStamp=clientRawExtra[196] + "/" + clientRawExtra[197]+ "/" + clientRawExtra[198] + " " + clientRawExtra[194] + ":" + clientRawExtra[195] ;
	atMaxOutTemp=clientRawExtra[313];
	atMaxOutTempTimeStamp=clientRawExtra[316] + "/" + clientRawExtra[317]+ "/" + clientRawExtra[318] + " " + clientRawExtra[314] + ":" + clientRawExtra[315] ;
	atMinOutTemp=clientRawExtra[319];
	atMinOutTempTimeStamp=clientRawExtra[322] + "/" + clientRawExtra[323]+ "/" + clientRawExtra[198] + " " + clientRawExtra[320] + ":" + clientRawExtra[321] ;
	mMaxOutTemp=clientRawExtra[61];
	mMaxOutTempTimeStamp=clientRawExtra[64] + "/" + clientRawExtra[65]+ "/" + clientRawExtra[66] + " " + clientRawExtra[62] + ":" + clientRawExtra[63] ;
	mMinOutTemp=clientRawExtra[67];
	mMinOutTempTimeStamp=clientRawExtra[70] + "/" + clientRawExtra[71]+ "/" + clientRawExtra[72] + " " + clientRawExtra[68] + ":" + clientRawExtra[69] ;	 
	ECRReady=1;
	}
	
}

function parseClientRawHour(rawHCR){
	var clientRawHour = rawHCR.split(" ");
	if(clientRawHour[0]!='12345')
	{
	getHCR();
	}
	else
	{
	
	for(var HCRcount=0;HCRcount<60;HCRcount++)
	{
	hourOutTemp[HCRcount]=clientRawHour[181+HCRcount];
	hourBaro[HCRcount]=clientRawHour[301+HCRcount];
	} 
	HCRReady=1; 
   }
   }
   
   function parseClientRawDaily(rawDCR){
	var clientRawDaily = rawDCR.split(" ");
	if(clientRawDaily[0]!='12345')
	{
	getDCR();
	}
	else
	{
	
	DCRReady=1; 
   }
   }

function parse24hr(raw24hr){

	// raw24hr is now the contents of csv file, how to split into arrays?

	// first split into lines
	lines24hr = raw24hr.split(/\n/g);
	
	// now for each line split into
	// Date, temp, humidity, dewpoint, pressure, wind ,gust ,wind dir, rain
	var get24hrcount=0;
	var dayOutTime= new Date();
	
	var dayOutTimeSplit=[];
	
	for(var hr24Count=0;hr24Count < lines24hr.length;hr24Count++)
	{
	if ((lines24hr[hr24Count].split(",")[1] > -999)&& (lines24hr[hr24Count].split(",")[5] > -999)) {
	// check if line is empty???
		var UTCoffset = dayOutTime.getTimezoneOffset();
		dayOutTimeSplit[get24hrcount] = lines24hr[hr24Count].split(",")[0].split("-");
		dayOutTime.setFullYear(parseInt(dayOutTimeSplit[get24hrcount][0]),dayOutTimeSplit[get24hrcount][1]-1,dayOutTimeSplit[get24hrcount][2]);
		dayOutTime.setHours(parseInt(dayOutTimeSplit[get24hrcount][3],10)-(UTCoffset/60));
		dayOutTime.setMinutes(parseInt(dayOutTimeSplit[get24hrcount][4],10));
		dayOutTime.setSeconds(0);
		dayOutTime.setMilliseconds(0);
		dayOutTemp[get24hrcount] = [ dayOutTime.getTime(),lines24hr[hr24Count].split(",")[1] ];
		dayOutWind[get24hrcount] = [ dayOutTime.getTime(),lines24hr[hr24Count].split(",")[6] ];
		dayBaro[get24hrcount] = [ dayOutTime.getTime(),lines24hr[hr24Count].split(",")[4] ];
		//document.write(dayOutTimeSplit[get24hrcount][0]+"-"+dayOutTimeSplit[get24hrcount][1]+"-"+dayOutTimeSplit[get24hrcount][2]+" "+dayOutTimeSplit[get24hrcount][3]+":"+dayOutTimeSplit[get24hrcount][4]+"  "+dayOutTime+" - "+dayOutTemp[get24hrcount][0]+"<BR>");

		if (hr24Count==0){
		//alert(UTCoffset );			
		}

		if ( dayOutTemp[get24hrcount]<dayOutTemp[get24hrcount-1])
		{
			//alert(dayOutTimeSplit[get24hrcount][0]+"-"+dayOutTimeSplit[get24hrcount][1]+"-"+dayOutTimeSplit[get24hrcount][2]+" "+dayOutTimeSplit[get24hrcount][3]+":"+dayOutTimeSplit[get24hrcount][4]);
			//alert(dayOutTime)
			//alert(parseInt(dayOutTimeSplit[get24hrcount][0]) +" "+parseInt(dayOutTimeSplit[get24hrcount][1])+"-"+parseInt(dayOutTimeSplit[get24hrcount][2])+"-"+parseInt(dayOutTimeSplit[get24hrcount][3])+"-"+parseInt(dayOutTimeSplit[get24hrcount][4]));
			//alert(dayOutTemp[get24hrcount][0]+" "+dayOutTemp[get24hrcount-1][0]);
		}
get24hrcount = get24hrcount +1;

	}
	}

	
	hr24Ready=1;

}
 
function parse7day(raw7day){

	// raw7day is now the contents of csv file, how to split into arrays?

	// first split into lines
	lines7day = raw7day.split(/\n/g);
	
	// now for each line split into
	// Date, temp, humidity, dewpoint, pressure, wind ,gust ,wind dir, rain
	var get7dayCount=0;
	var weekOutTime= new Date();
	
	var weekOutTimeSplit=[];
	
	for(var day7Count=0;day7Count < lines7day.length;day7Count++)
	{
	if ((lines7day[day7Count].split(",")[1] > -999)&& (lines7day[day7Count].split(",")[5] > -999)) {
	// check if line is empty???
		var UTCoffset = weekOutTime.getTimezoneOffset();
		weekOutTimeSplit[get7dayCount] = lines7day[day7Count].split(",")[0].split("-");
		weekOutTime.setFullYear(parseInt(weekOutTimeSplit[get7dayCount][0]),weekOutTimeSplit[get7dayCount][1]-1,weekOutTimeSplit[get7dayCount][2]);
		weekOutTime.setHours(parseInt(weekOutTimeSplit[get7dayCount][3],10)-(UTCoffset/60));
		weekOutTime.setMinutes(parseInt(weekOutTimeSplit[get7dayCount][4],10));
		weekOutTime.setSeconds(0);
		weekOutTime.setMilliseconds(0);
		weekOutTemp[get7dayCount] = [ weekOutTime.getTime(),lines7day[day7Count].split(",")[1] ];
		weekOutWind[get7dayCount] = [ weekOutTime.getTime(),lines7day[day7Count].split(",")[6] ];
		//document.write(weekOutTimeSplit[get7dayCount][0]+"-"+weekOutTimeSplit[get7dayCount][1]+"-"+weekOutTimeSplit[get7dayCount][2]+" "+weekOutTimeSplit[get7dayCount][3]+":"+weekOutTimeSplit[get7dayCount][4]+"  "+weekOutTime+" - "+weekOutTemp[get7dayCount][0]+"<BR>");

		if (day7Count==0){
		//alert(UTCoffset );			
		}

		if ( weekOutTemp[get7dayCount]<weekOutTemp[get7dayCount-1])
		{
			//alert(weekOutTimeSplit[get7dayCount][0]+"-"+weekOutTimeSplit[get7dayCount][1]+"-"+weekOutTimeSplit[get7dayCount][2]+" "+weekOutTimeSplit[get7dayCount][3]+":"+weekOutTimeSplit[get7dayCount][4]);
			//alert(weekOutTime)
			//alert(parseInt(weekOutTimeSplit[get7dayCount][0]) +" "+parseInt(weekOutTimeSplit[get7dayCount][1])+"-"+parseInt(weekOutTimeSplit[get7dayCount][2])+"-"+parseInt(weekOutTimeSplit[get7dayCount][3])+"-"+parseInt(weekOutTimeSplit[get7dayCount][4]));
			//alert(weekOutTemp[get7dayCount][0]+" "+weekOutTemp[get7dayCount-1][0]);
		}
get7dayCount = get7dayCount +1;

	}
	}
	

	
	day7Ready=1;

}   

function parseSolarToday(rawSolarToday){

			
			
	// first split into lines
	linesSolarToday = rawSolarToday.split(/\n/g);
	var solarTodayMinimum=0;
	
	if (almanacReady == 1) {
	// Now do through each line in turn, and split into the correct variables
			for(var solarTodayCount=0;solarTodayCount < linesSolarToday.length-1;solarTodayCount++) {
			// Split the line by spaces
			linesSolarSplit = linesSolarToday[solarTodayCount].split(" ");
			// Split the date by hyphens, and the time by colon, so left with just YY,MM,DD and hh:mm:ss
			dateSolarSplit = linesSolarSplit[0].split("-");
			timeSolarSplit = linesSolarSplit[1].split(":");
			
							
			// On first run get values for sunrise and sunset to ensure graph covers daylight hours, can only calc if almanac already has loaded sunrise/sunset
			if (solarTodayCount==0 && almanacReady == 1)
			{
			sunriseSplit = sunrise.split(":");
			sunsetSplit = sunset.split(":");			
			solarSunriseTime = new Date(dateSolarSplit[0],(dateSolarSplit[1]-1),dateSolarSplit[2],sunriseSplit[0],sunriseSplit[1]);
			//solarSunriseTime = new Date(2011,3,4,sunriseSplit[0],sunriseSplit[1]);
			//alert (dateSolarSplit[0]+"\n"+dateSolarSplit[1]+"\n"+dateSolarSplit[2]+"\n"+sunriseSplit[0]+"\n"+sunriseSplit[1]+"\n"+solarSunriseTime);
			
			solarTodayWatts[0] = [solarSunriseTime,0];
			solarTodayTotal[0]=[solarSunriseTime,0];
			solarSunsetTime = new Date(dateSolarSplit[0],(dateSolarSplit[1]-1),dateSolarSplit[2],sunsetSplit[0],sunsetSplit[1],0);
			solarTodayMinimum = linesSolarSplit[3];
			}
			
			
			// Create a DateTime value from that split
			var solarTodayTime = new Date(dateSolarSplit[0],(dateSolarSplit[1]-1),dateSolarSplit[2],timeSolarSplit[0],timeSolarSplit[1],timeSolarSplit[2]);
			
			// Create array containing pairs to graph
			solarTodayWatts[solarTodayCount+1] = [ solarTodayTime,linesSolarSplit[2] ];
			solarTodayTotal[solarTodayCount+1] = [ solarTodayTime,((linesSolarSplit[3]-solarTodayMinimum)*1000) ];
			
			}
			
			
			
			//if (solarSunsetTime > solarTodayTime)
			//{
			 // solarTodayWatts[linesSolarToday.length] = [ solarSunsetTime, 0 ];
			//}
			//solarTodayWatts[linesSolarToday.length] = [ solarTodayTime, 0 ];
			
			}
	                solarTodayReady=1;
	                }
			

   function parseAlmanac(almanacData){
   	
	var almanac = almanacData.split(" ");
	sunrise=almanac[0];
	sunset = almanac[1];
	dawn=almanac[2];
	dusk=almanac[3];

	almanacReady=1;
}

function parseSolarCurrent(solarCurrentData){
   	
	var solarCurrent = solarCurrentData.split(" ");
	
	solarDate=solarCurrent[0];
	solarTime=solarCurrent[1];
	solarWatts=solarCurrent[2];
	solarMax=solarCurrent[3];
	solarToday = 1000*solarCurrent[4];
	var solarPercentFloat=100*solarWatts/1700;
	solarPercent = solarPercentFloat.toFixed(1);
	var solarMaxFloat = 100*solarMax/1700;
	solarMaxPercent = solarMaxFloat.toFixed(1); 


	solarCurrentReady=1;
}

function parseSolarMonthlyAverages(solarMonthlyAveragesData){
   	
			
	// first split into lines
	linesSolarMonthlyAverages = solarMonthlyAveragesData.split(/\n/g);

	

	// Now do through each line in turn, and split into the correct variables
			for(var solarMonthlyAveragesCount=0;solarMonthlyAveragesCount < linesSolarMonthlyAverages.length-1;solarMonthlyAveragesCount++) {
			// Split the line by spaces
			linesSolarMonthlyAveragesSplit = linesSolarMonthlyAverages[solarMonthlyAveragesCount].split(" ");
			// Split the date by hyphens, and the time by colon, so left with just YY,MM,DD and hh:mm:ss
			
			// Create array containing pairs to graph
			//solarMonthlyAverages[solarMonthlyAveragesCount] = [ solarMonthlyAveragesCount+1,linesSolarMonthlyAveragesSplit[1] ];
		solarMonthlyAverages[solarMonthlyAveragesCount] = [ linesSolarMonthlyAveragesSplit[2],linesSolarMonthlyAveragesSplit[1] ];

		
			}
	                solarMonthlyAveragesReady=1;
	                }   	



function parseSolarDayHistory(solarDayHistoryData){
		
			
	// first split into lines
	linesSolarDayHistory = solarDayHistoryData.split(/\n/g);

	

	// Now do through each line in turn, and split into the correct variables
			for(var solarDayHistoryCount=0;solarDayHistoryCount < linesSolarDayHistory.length-1;solarDayHistoryCount++) {
			// Split the line by spaces
			linesSolarDayHistorySplit = linesSolarDayHistory[solarDayHistoryCount].split(" ");
			// Split the date by hyphens, and the time by colon, so left with just YY,MM,DD and hh:mm:ss
			dateSolarDayHistorySplit = linesSolarDayHistorySplit[0].split("-");
	
			// Create a DateTime value from that split
			var solarDayHistoryTime = new Date(dateSolarDayHistorySplit[0],(dateSolarDayHistorySplit[1]-1),dateSolarDayHistorySplit[2]);
			
			// Create array containing pairs to graph
			solarDailyHistory[solarDayHistoryCount] = [ solarDayHistoryTime,linesSolarDayHistorySplit[1] ];
		
		
			}
	                solarDayHistoryReady=1;
	                }   	



function updateNewCR(){

	if (http.readyState == 4 && http.status == 200) {   
   
		parseClientRaw(http.responseText);
	}
}

function updateNewECR(){
	if (httpECR.readyState == 4 && httpECR.status == 200) {        
		parseClientRawExtra(httpECR.responseText);
	}
}

function updateNewHCR(){
	if (httpHCR.readyState == 4 && httpHCR.status == 200) {        
		parseClientRawHour(httpHCR.responseText);
	}
}

function updateNewDCR(){
	if (httpDCR.readyState == 4 && httpDCR.status == 200) {        
		parseClientRawDaily(httpDCR.responseText);
	}
}

function updateNew24hr(){
	if (http24hr.readyState == 4 && http24hr.status == 200) {        
		parse24hr(http24hr.responseText);
	}
}

function updateNew7day(){
	if (http7day.readyState == 4 && http7day.status == 200) {        
		parse7day(http7day.responseText);
	}
}

function updateNewAlmanac(){
	if (httpAlmanac.readyState == 4 && httpAlmanac.status == 200) {        
		parseAlmanac(httpAlmanac.responseText);
		
	}
}

function updateNewSolarCurrent(){
	if (httpSolarCurrent.readyState == 4 && httpSolarCurrent.status == 200) {        
		parseSolarCurrent(httpSolarCurrent.responseText);
		
	}
}
function updateNewSolarToday(){
	if (httpSolarToday.readyState == 4 && httpSolarToday.status == 200) {        
		parseSolarToday(httpSolarToday.responseText);
		
	}
}
function updateNewSolarDayHistory(){
	if (httpSolarDayHistory.readyState == 4 && httpSolarDayHistory.status == 200) {        
		parseSolarDayHistory(httpSolarDayHistory.responseText);
		
	}
}
function updateNewSolarMonthlyAverages(){
	if (httpSolarMonthlyAverages.readyState == 4 && httpSolarMonthlyAverages.status == 200) {        
		parseSolarMonthlyAverages(httpSolarMonthlyAverages.responseText);
		
	}
}


function getCR(){
	http=new XMLHttpRequest();
	http.open('get',clientrawPath+"clientraw.txt?"+new Date().getTime(),'true');
	http.onreadystatechange = updateNewCR;
	http.send(null);
	
	
}

function getECR(){
	httpECR=new XMLHttpRequest();
	httpECR.open('get',clientrawPath+"clientrawextra.txt?"+new Date().getTime(),'true');
	httpECR.onreadystatechange = updateNewECR;
	httpECR.send(null);
	
	
}

function getHCR(){
	httpHCR=new XMLHttpRequest();
	httpHCR.open('get',clientrawPath+"clientrawhour.txt?"+new Date().getTime(),'true');
	httpHCR.onreadystatechange = updateNewHCR;
	httpHCR.send(null);
	
}
function getDCR(){
	httpDCR=new XMLHttpRequest();
	httpDCR.open('get',clientrawPath+"clientrawdaily.txt?"+new Date().getTime(),'true');
	httpDCR.onreadystatechange = updateNewDCR;
	httpDCR.send(null);
	
}

function get24hr(){
	http24hr=new XMLHttpRequest();
	http24hr.open('get',clientrawPath+"24hrGraphData.txt?"+new Date().getTime(),'true');
	http24hr.onreadystatechange = updateNew24hr;
	http24hr.send(null);
}

function get7day(){
	http7day=new XMLHttpRequest();
	http7day.open('get',clientrawPath+"7dayGraphData.txt?"+new Date().getTime(),'true');
	http7day.onreadystatechange = updateNew7day;
	http7day.send(null);
}

function getAlmanac(){
	httpAlmanac=new XMLHttpRequest();
	httpAlmanac.open('get',clientrawPath+"almanac.txt?"+new Date().getTime(),'true');
	httpAlmanac.onreadystatechange = updateNewAlmanac;
	httpAlmanac.send(null);
	
}
function getSolarCurrent(){
	httpSolarCurrent=new XMLHttpRequest();
	httpSolarCurrent.open('get',"/content/solar/currentpower?"+new Date().getTime(),'true');
	httpSolarCurrent.onreadystatechange = updateNewSolarCurrent;
	httpSolarCurrent.send(null);
	
}
function getSolarToday(){
	httpSolarToday=new XMLHttpRequest();
	httpSolarToday.open('get',"/content/solar/todaypower?"+new Date().getTime(),'true');
	httpSolarToday.onreadystatechange = updateNewSolarToday;
	httpSolarToday.send(null);
	
}
function getSolarDayHistory(){
	httpSolarDayHistory=new XMLHttpRequest();
	httpSolarDayHistory.open('get',"/content/solar/powerhistory?"+new Date().getTime(),'true');
	httpSolarDayHistory.onreadystatechange = updateNewSolarDayHistory;
	httpSolarDayHistory.send(null);
	
}
function getSolarMonthlyAverages(){
	httpSolarMonthlyAverages=new XMLHttpRequest();
	httpSolarMonthlyAverages.open('get',"/content/solar/monthlyaverages?"+new Date().getTime(),'true');
	httpSolarMonthlyAverages.onreadystatechange = updateNewSolarMonthlyAverages;
	httpSolarMonthlyAverages.send(null);
	
}

function dataCheck() {
//alert(CRReady+" "+ ECRReady+" "+ HCRReady+" "+ almanacReady+" "+ DCRReady)
	 if(CRReady==0 || ECRReady==0 || HCRReady==0|| almanacReady==0 || DCRReady==0 || hr24Ready==0 || day7Ready==0 || solarCurrentReady==0 || solarTodayReady==0 || solarDayHistoryReady==0 || solarMonthlyAveragesReady==0) {
		
	}
	else
	{
	
		// Reset flags now that data has been loaded
		dataReady=1;
		CRReady=0;
		ECRReady=0;
		HCRReady=0;
		DCRReady=0;
		hr24Ready=0;
		day7Ready=0;
		almanacReady=0;
		solarCurrentReady=0;
		solarDayHistoryReady=0;
		solarTodayReady=0;
		solarMonthlyAveragesReady=0;
		
	}
}

function getWXData () {

getAlmanac();
getCR();
getECR();
getHCR();
getDCR();
get24hr();
get7day();
getSolarMonthlyAverages();
getSolarCurrent();
getSolarDayHistory();
getSolarToday();
startDataUpdate();
}