// Base CookoutCalculator state class
// Gennady Yurkin
// $Id: CookoutCalculator.js,v 1.6.2.4.2.16 2007/05/23 13:15:13 akovalev Exp $

var CookoutCalculatorState = Base.extend
({
	ContextHelpMessage : "",
	IsGuestUser : false, 
	CCTHIS      : null,
	
	constructor : function(contextHelpMessage, isGuestUser)
	{
		this.ContextHelpMessage = contextHelpMessage;
		this.IsGuestUser        = isGuestUser;
		CCTHIS                  = this;
	}, 
	
	FridgeTimeSelected : function(cookout, isFridgeEnabled)
	{
		return CCTHIS.GetFridgeTimeState(isFridgeEnabled, cookout);
	},

	WhatsGrillingAction : function(grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		return CCTHIS.GetGrillingState_GCF(grillingState, cookout, isFridgeEnabled);
	},

	StoreGrillingFooterChanged : function(isCookoutStore, grillingState, cookout, isFridgeEnabled)
	{
		return CCTHIS.GetGrillingState_GCF(grillingState, cookout, isFridgeEnabled);
	},

	CalculatorTabSelected : function(cookout, isTimeLine, isFridgeEnabled, grillingState)
	{
		return CCTHIS.GetGrillingState_GCF(grillingState, cookout, isFridgeEnabled);
	},
	
	GetFridgeTimeState : function(isFridgeEnabled, cookout)
	{
		if(!isFridgeEnabled) 
			return new NoReminderState(IsGuestUser);

		if(cookout.FridgeFactor >= 0) 
			return new ReminderActivatedState(IsGuestUser);
		else 
			return new NoReminderActivatedState(IsGuestUser);
	},

	GetGrillingState_CF : function(cookout, isFridgeEnabled)
	{
		if(!isFridgeEnabled && cookout.Count > 0) 
			return new GrillingNoActivatedState(IsGuestUser);
		if(!isFridgeEnabled && cookout.Count == 0) 
			return new GrillingListEmptyState(IsGuestUser);

		if(cookout.FridgeFactor == -1) 
			return new GrillingNoReminderState(IsGuestUser);
		else 
			return new GrillingReminderActivatedState(IsGuestUser);
	},
	
	GetGrillingState_GCF : function(grillingState, cookout, isFridgeEnabled)
	{
		if(CCTHIS.IsStoreState(grillingState)) 
		{
			return new StoreCookoutItemState(IsGuestUser, grillingState);
		}
		else
		{
			if(grillingState instanceof AddState)
			{
				if(cookout.Count == 0) return new GrillingListEmptyState(IsGuestUser);
				return CCTHIS.GetGrillingState_CF(cookout, isFridgeEnabled);
			}
			else return new UpdateItemState(IsGuestUser);
		}
		
	},
		
	IsStoreState : function(grillingState)
	{
		return (grillingState instanceof StoreAndAddState) || (grillingState instanceof StoreAndUpdateState);
	}, 
	
	//	Method is called for current page state (A) and returns the next state (B).
	//  This new state (B) should be saved when redirecting to other page.
	//	When user returns to current page, it must be initialized exactly with this new state (B).
	GetReturnState : function(isFridgeEnabled)
	{
		if(Cookout.Count == 0) return "GrillingListEmptyState";
		if(!isFridgeEnabled) return "GrillingNoActivatedState";
		if(Cookout.FridgeFactor == -1) return "GrillingNoReminderState";
		else return "GrillingReminderActivatedState";
	}
});


var ContinueAddingState = CookoutCalculatorState.extend
({
	constructor : function(message, isGuestUser)
	{
		this.base(message, isGuestUser);
	},
	
	FridgeTimeSelected : function(cookout, isFridgeEnabled)
	{
		return CCTHIS.GetGrillingState_CF(cookout, isFridgeEnabled);
	},
	
	WhatsGrillingAction : function(grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		if(CCTHIS.IsStoreState(grillingState)) 
			return new StoreCookoutItemState(IsGuestUser, grillingState);

		if(grillingState instanceof UpdateState) 
			return new UpdateItemState(IsGuestUser);
		else 
			return CCTHIS.GetGrillingState_CF(cookout, isFridgeEnabled);
	},
	
	StoreGrillingFooterChanged : function(isCookoutStore, grillingState, cookout, isFridgeActivated)
	{
		if(isCookoutStore && !CCTHIS.IsStoreState(grillingState)) 
		{
			return new CookoutStoreInFavoritesState(IsGuestUser);
		}

		return CCTHIS;
	},

	CalculatorTabSelected : function(cookout, isTimeLine, isFridgeEnabled, grillingState)
	{
		if(isTimeLine) return CCTHIS.GetFridgeTimeState(isFridgeEnabled, cookout);
		return CCTHIS;
	}
});

var CookoutStoreInFavoritesState = CookoutCalculatorState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.FooterFavoriteMessage, isGuestUser);
	},
	
	FridgeTimeSelected : function(cookout, isFridgeEnabled)
	{
		return CCTHIS;
	},

	WhatsGrillingAction : function (grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		if(CCTHIS.IsStoreState(grillingState)) return new StoreCookoutItemState(IsGuestUser, grillingState);
		if(cookout.Count == 0) return new GrillingListEmptyState(IsGuestUser);
		ResetselectedItemIdFromWhatsGrillingList();
		return CCTHIS;
	},

	StoreGrillingFooterChanged : function(isCookoutStore, grillingState, cookout, isFridgeActivated)
	{
		if(!isCookoutStore)
		{
			if(CCTHIS.IsStoreState(grillingState)) return new StoreCookoutItemState(IsGuestUser, grillingState);
			if(cookout.Count == 0) return new GrillingListEmptyState(IsGuestUser);
			if (selectedItemIdFromWhatsGrillingList != -1) return new UpdateItemState(IsGuestUser);
			else return CCTHIS.GetGrillingState_CF(cookout, isFridgeActivated);
		}

		return CCTHIS;
	},

	CalculatorTabSelected : function(cookout, isTimeLine, isFridgeEnabled, grillingState)
	{
		return CCTHIS.GetFridgeTimeState(isFridgeEnabled, cookout);
	}
});

var GrillingListEmptyState = CookoutCalculatorState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.DefaultContextMessage, isGuestUser);
	},

	FridgeTimeSelected : function (cookout, isFridgeEnabled)
	{
		return CCTHIS;
	},

	WhatsGrillingAction : function (grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		if(CCTHIS.IsStoreState(grillingState)) return new StoreCookoutItemState(IsGuestUser, grillingState);
		if(cookout.Count > 0) return CCTHIS.GetGrillingState_CF(cookout, isFridgeEnabled);

		return CCTHIS;
	},

	StoreGrillingFooterChanged : function (isCookoutStore, grillingState, cookout, isFridgeEnabled)
	{
		if(isCookoutStore) return new CookoutStoreInFavoritesState(IsGuestUser);
		else return CCTHIS;
	},

	CalculatorTabSelected : function(cookout, isTimeLine, isFridgeEnabled, grillingState)
	{
		if(isTimeLine) return CCTHIS.GetFridgeTimeState(isFridgeEnabled, cookout);
		else return CCTHIS;
	}
});

var GrillingNoActivatedState = ContinueAddingState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.GrillingReminderNoActivated, isGuestUser);
	}
});

var GrillingNoReminderState = ContinueAddingState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.GrillingNoReminder, isGuestUser);
	}
});

var GrillingReminderActivatedState = ContinueAddingState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.GrillingReminderActivated, isGuestUser);
	}
});

var NoReminderActivatedState = CookoutCalculatorState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.ReminderNoActivated, isGuestUser);
	},
	
	WhatsGrillingAction : function(grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		return CCTHIS;
	},
	
	GetReturnState : function(isFridgeEnabled, isPrintCookout)
	{
		if(isPrintCookout) return 'NoReminderActivatedState';
		else return this.base(isFridgeEnabled);
	}
});

var NoReminderState = CookoutCalculatorState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.NoReminder, isGuestUser);
	},
	
	WhatsGrillingAction : function(grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		return CCTHIS;
	},
	
	GetReturnState : function(isFridgeEnabled, isPrintCookout)
	{
		if(isPrintCookout) return 'NoReminderState';
		else return this.base(isFridgeEnabled);
	}
});

var ReminderActivatedState = CookoutCalculatorState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.ReminderActivated, isGuestUser);
	},
	
	WhatsGrillingAction : function(grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		return CCTHIS;
	},

	GetReturnState : function(isFridgeEnabled, isPrintCookout)
	{
		if(isPrintCookout) return 'ReminderActivatedState';
		else return this.base(isFridgeEnabled);
	}
});

var StoreCookoutItemState = CookoutCalculatorState.extend
({
	constructor : function (isGuestUser, grillingSate)
	{
		this.base(Config.StoreAndAddStateMessage, isGuestUser);
		
		if(grillingSate instanceof StoreAndUpdateState) 
			CCTHIS.ContextHelpMessage = Config.StoreAndUpdateStateMessage;
	},

	FridgeTimeSelected : function(cookout, isFridgeEnabled)
	{
		return CCTHIS;
	},

	WhatsGrillingAction : function(grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		if(!CCTHIS.IsStoreState(grillingState))
		{
			if(isStoreCookoutChecked) return new CookoutStoreInFavoritesState(IsGuestUser);
			if(grillingState instanceof UpdateState) return new UpdateItemState(IsGuestUser);
			if(cookout.Count == 0) return new GrillingListEmptyState(IsGuestUser);
			else return CCTHIS.GetGrillingState_CF(cookout, isFridgeEnabled);
		}
		return CCTHIS;
	},

	CalculatorTabSelected : function(cookout, isTimeLine, isFridgeEnabled, grillingState)
	{
		return CCTHIS.GetFridgeTimeState(isFridgeEnabled, cookout);
	}
});

var UpdateItemState = CookoutCalculatorState.extend
({
	constructor : function(isGuestUser)
	{
		this.base(Config.UpdateStateMessage, isGuestUser);
		if(CCTHIS.IsGuestUser) CCTHIS.ContextHelpMessage = Config.GuestUpdateStateMessage;
	},

	FridgeTimeSelected : function(cookout, isFridgeEnabled)
	{
		return CCTHIS;
	},

	WhatsGrillingAction : function(grillingState, cookout, isStoreCookoutChecked, isFridgeEnabled)
	{
		if(CCTHIS.IsStoreState(grillingState)) 
			return new StoreCookoutItemState(CCTHIS.IsGuestUser, grillingState);

		if(grillingState instanceof AddState)
		{
			if(cookout.Count == 0)
			{
				ResetselectedItemIdFromWhatsGrillingList();
				return new GrillingListEmptyState(IsGuestUser);
			}
			else 
			{
				ResetselectedItemIdFromWhatsGrillingList();
				return CCTHIS.GetGrillingState_CF(cookout, isFridgeEnabled);
			}
		}
		

		return CCTHIS;
	},

	StoreGrillingFooterChanged : function(isCookoutStore, grillingState, cookout, isFridgeEnabled)
	{
		if(isCookoutStore) return new CookoutStoreInFavoritesState(IsGuestUser);///????????????????
		return CCTHIS;
	},

	CalculatorTabSelected : function(cookout, isTimeLine, isFridgeEnabled, grillingState)
	{
		return CCTHIS.GetFridgeTimeState(isFridgeEnabled, cookout);
	}
});

//------------------------- Cookout Calculator ----------------------------------------
// This class implements logic on server partially.

var CookoutCalculator = Base.extend
({
	_CalculatorState : null,
	_WhatsGrilling   : null,
	CTHIS            : null,
	
	constructor : function(whatsGrilling, startState)
	{
		CalculatorState = startState;
		_WhatsGrilling  = whatsGrilling;
		CTHIS = this;
		CTHIS.WhatsGrillingAction();
		CTHIS.UpdateControlsView();
	},
	
	ResetselectedItemIdFromWhatsGrillingList : function()
	{
		ResetselectedItemIdFromWhatsGrillingList();
	},
	
	ItemFavoriteChekedChanged : function(sender)
	{
		_WhatsGrilling.FavoriteChekedChanged(sender);
		CTHIS.StoreItemInFavoriteCheckedChanged();
		return false;
	},
	
	WhatsGrillingClearState : function()
	{
		_WhatsGrilling.ClearState();
		CTHIS.WhatsGrillingAction();
	},
	
	WhatsGrillingRemove : function()
	{
		_WhatsGrilling.RemoveClick();
		CTHIS.WhatsGrillingAction();
	},
	
	WhatsGrillingCancel : function()
	{
		_WhatsGrilling.CancelClick();
		CTHIS.WhatsGrillingAction();
	},
	
	WhatsGrillingItemSelected : function(id)
	{
		_WhatsGrilling.ItemSelected(id);
		selectedItemIdFromWhatsGrillingList = id;
		CTHIS.WhatsGrillingAction();
	},

	FridgeTimeChanged : function(sender)
	{
		Cookout.FridgeFactor = sender.value;
		CalculatorState = CalculatorState.FridgeTimeSelected(Cookout, !sender.disabled);
		CTHIS.UpdateControlsView();
		return IsTimelineSelected;
	},
	
	WhatsGrillingAction : function()
	{
		var cookoutFavorite = get_cookoutFavorite();
		var fridgeTime      = get_FridgeTime();
		
		CalculatorState = CalculatorState.WhatsGrillingAction(GrillingState, Cookout, cookoutFavorite.checked, !fridgeTime.disabled);
		CTHIS.UpdateControlsView();
	}, 
	
	StoreItemInFavoriteCheckedChanged : function()
	{
		var cookoutFavorite = get_cookoutFavorite();
		var fridgeTime      = get_FridgeTime();
		
		CalculatorState = CalculatorState.WhatsGrillingAction(GrillingState, Cookout, cookoutFavorite.checked, !fridgeTime.disabled);
		CTHIS.UpdateControlsView();
	},
	
	StoreCookoutInFavoriteChecked : function()
	{
		var cookoutFavorite = get_cookoutFavorite();
		var fridgeTime      = get_FridgeTime();

		CalculatorState = CalculatorState.StoreGrillingFooterChanged(cookoutFavorite.checked, GrillingState, Cookout, !fridgeTime.disabled);
		CTHIS.UpdateControlsView();
		return false;
	},
	
	SelectedTabChanged : function(isTimeLine)
	{
		var cookoutFavorite = get_cookoutFavorite();
		var fridgeTime      = get_FridgeTime();

		CalculatorState = CalculatorState.CalculatorTabSelected(Cookout, isTimeLine, !fridgeTime.disabled, GrillingState);
		CTHIS.UpdateControlsView();
	},
	
	UpdateControlsView : function()
	{
		var contextHelp = get_message();
		contextHelp.innerHTML = CalculatorState.ContextHelpMessage;
	},
	
	AddItemClick : function(cutType, cut, thickness, doneness)
	{
		_WhatsGrilling.AddItemClick(cutType, cut, thickness, doneness);
		CTHIS.UpdateControlsView();
	},
	
	GetReturnState : function(isPrintCookout)
	{
		var fridgeTime = get_FridgeTime();
		return CalculatorState.GetReturnState(!fridgeTime.disabled, isPrintCookout);
	}
});

function PreChangePage(sender)
{
	grillInfo.SaveGrillInfo(sender.href);
	return false;
}

function PrePrintCookout()
{
	Anthem_InvokeControlMethod
	(
		"timeLine", 
		'PrintCookoutClick', 
		[cookoutCalculator.GetReturnState(true)], 
		function(result)
		{
			ChangeLocation(result.value);
		}
	);
	
	return false;
}

function ChangeLocation(location)
{
	window.document.location = location;
}
function ResetselectedItemIdFromWhatsGrillingList()
{
	selectedItemIdFromWhatsGrillingList = -1;
}

//---------------------------------Cookout Calculator Valiables------------------------------
var cookoutCalculator  = null;
var IsTimelineSelected = false;
var StartCalculatorState;

var cutTypeValue;
var cutValue;
var thicknessValue;
var donenessValue;

var callCookieName;
var domain;

var selectedItemIdFromWhatsGrillingList = -1;
//-----------------------------------Cookout Calculator Init---------------------------------

function CookoutCalculatorInit()
{
	var whatsGrilling  = new WhatsGrilling();
	var startState     = StartCalculatorState;//GetStartCalculatorState();
	cookoutCalculator  = new CookoutCalculator(whatsGrilling, startState);
}

function SynchronizeWithServer()
{
	var cookie = Get_Cookie("server_call_cookie");
	if(cookie == null)
	{
		Anthem_InvokePageMethod('InitCalculatorState', [], function(result) {});
	}
	else
	{
		Delete_Cookie("server_call_cookie", "/");
	}
	
}

function CopyCookoutFields(currentCookout)
{
	Cookout.Name           = currentCookout.Name;
	Cookout.Count          = currentCookout.Count;
	Cookout.FridgeFactor   = currentCookout.FridgeFactor;
	Cookout.Temperature    = currentCookout.Temperature;
	Cookout.DateGrill      = currentCookout.DateGrill;
	Cookout.TimeHour       = currentCookout.TimeHour;
	Cookout.TimeMin        = currentCookout.TimeMin;
	Cookout.FromStartGrill = currentCookout.FromStartGrill;
	
	Cookout.Grill.AssociatedGrillId = currentCookout.Grill.AssociatedGrillId;
	Cookout.Grill.Covered           = currentCookout.Grill.Covered;
	Cookout.Grill.GrillType.Name    = currentCookout.Grill.GrillType.Name;
	Cookout.Grill.Fire.Id           = currentCookout.Grill.Fire.Id;
	Cookout.Grill.PrepTime.Id       = currentCookout.Grill.PrepTime.Id;

	CopyCookoutItemsList(currentCookout);
}

function CopyCookoutItemsList(currentCookout)
{
	Cookout.CloneItems = new Object();
	
	for(var property in currentCookout.CloneItems)
	{
		Cookout.CloneItems[property] = new Object();
		
		Cookout.CloneItems[property].Id = currentCookout.CloneItems[property].Id;
		Cookout.CloneItems[property].Qty = currentCookout.CloneItems[property].Qty;
		Cookout.CloneItems[property].Name = currentCookout.CloneItems[property].Name;
		Cookout.CloneItems[property].Notes = currentCookout.CloneItems[property].Notes;
		Cookout.CloneItems[property].DublicateNumber = currentCookout.CloneItems[property].DublicateNumber;
		Cookout.CloneItems[property].CutType = currentCookout.CloneItems[property].CutType;
		Cookout.CloneItems[property].FridgeFactor = currentCookout.CloneItems[property].FridgeFactor;
		
		Cookout.CloneItems[property].Cut = new Object();
		Cookout.CloneItems[property].Cut.Id = currentCookout.CloneItems[property].Cut.Id;
		Cookout.CloneItems[property].Cut.PicId = currentCookout.CloneItems[property].Cut.PicId;
		Cookout.CloneItems[property].Cut.Name = currentCookout.CloneItems[property].Cut.Name;
		Cookout.CloneItems[property].Cut.Desc = currentCookout.CloneItems[property].Cut.Desc;
		Cookout.CloneItems[property].Cut.FridgeFactor = currentCookout.CloneItems[property].Cut.FridgeFactor;
		
		Cookout.CloneItems[property].Thickness = new Object();
		Cookout.CloneItems[property].Thickness.Id = currentCookout.CloneItems[property].Thickness.Id;
		Cookout.CloneItems[property].Thickness.Name = currentCookout.CloneItems[property].Thickness.Name;

		Cookout.CloneItems[property].Doneness = new Object();
		Cookout.CloneItems[property].Doneness.Id = currentCookout.CloneItems[property].Doneness.Id;
		Cookout.CloneItems[property].Doneness.Name = currentCookout.CloneItems[property].Doneness.Name;
	}
}