# -*- encoding: utf-8 -*-
import clr
clr.AddReference("System")
import System
from slidescgv5mvvm import *
import StaticLib
from Wtvision.Sports.Models.Football import FootballEvents, FootballEventAttributes, EPenaltyKickResult
from System import TimeSpan, Tuple, ValueTuple


class FormViewModel(ObservableObject):
	def __init__(self, appCore, project, script):
		self.appCore = appCore
		self.project = project
		self.script = script

		auxGame = self.project.ScriptingObjects["Game"] if self.project.ScriptingObjects.ContainsKey("Game") else None
		self.Game = None if not auxGame else auxGame

		self.homeTeamName = ""
		self.awayTeamName = ""

		self.round1 = 1
		self.round2 = 2
		self.round3 = 3
		self.round4 = 4
		self.round5 = 5
		
		self.isHomeStarting = True
		
		self.homeGoal1IsChecked = False
		self.homeGoal2IsChecked = False
		self.homeGoal3IsChecked = False
		self.homeGoal4IsChecked = False
		self.homeGoal5IsChecked = False
		self.homeMissed1IsChecked = False
		self.homeMissed2IsChecked = False
		self.homeMissed3IsChecked = False
		self.homeMissed4IsChecked = False
		self.homeMissed5IsChecked = False

		self.awayGoal1IsChecked = False
		self.awayGoal2IsChecked = False
		self.awayGoal3IsChecked = False
		self.awayGoal4IsChecked = False
		self.awayGoal5IsChecked = False
		self.awayMissed1IsChecked = False
		self.awayMissed2IsChecked = False
		self.awayMissed3IsChecked = False
		self.awayMissed4IsChecked = False
		self.awayMissed5IsChecked = False

		self.homeGoal1ClickCommand = ScriptRelayCommand(self.script, self.HomeGoal1Action, lambda arg: True)
		self.homeGoal2ClickCommand = ScriptRelayCommand(self.script, self.HomeGoal2Action, lambda arg: True)
		self.homeGoal3ClickCommand = ScriptRelayCommand(self.script, self.HomeGoal3Action, lambda arg: True)
		self.homeGoal4ClickCommand = ScriptRelayCommand(self.script, self.HomeGoal4Action, lambda arg: True)
		self.homeGoal5ClickCommand = ScriptRelayCommand(self.script, self.HomeGoal5Action, lambda arg: True)
		self.homeMissed1ClickCommand = ScriptRelayCommand(self.script, self.HomeMissed1Action, lambda arg: True)
		self.homeMissed2ClickCommand = ScriptRelayCommand(self.script, self.HomeMissed2Action, lambda arg: True)
		self.homeMissed3ClickCommand = ScriptRelayCommand(self.script, self.HomeMissed3Action, lambda arg: True)
		self.homeMissed4ClickCommand = ScriptRelayCommand(self.script, self.HomeMissed4Action, lambda arg: True)
		self.homeMissed5ClickCommand = ScriptRelayCommand(self.script, self.HomeMissed5Action, lambda arg: True)

		self.awayGoal1ClickCommand = ScriptRelayCommand(self.script, self.AwayGoal1Action, lambda arg: True)
		self.awayGoal2ClickCommand = ScriptRelayCommand(self.script, self.AwayGoal2Action, lambda arg: True)
		self.awayGoal3ClickCommand = ScriptRelayCommand(self.script, self.AwayGoal3Action, lambda arg: True)
		self.awayGoal4ClickCommand = ScriptRelayCommand(self.script, self.AwayGoal4Action, lambda arg: True)
		self.awayGoal5ClickCommand = ScriptRelayCommand(self.script, self.AwayGoal5Action, lambda arg: True)
		self.awayMissed1ClickCommand = ScriptRelayCommand(self.script, self.AwayMissed1Action, lambda arg: True)
		self.awayMissed2ClickCommand = ScriptRelayCommand(self.script, self.AwayMissed2Action, lambda arg: True)
		self.awayMissed3ClickCommand = ScriptRelayCommand(self.script, self.AwayMissed3Action, lambda arg: True)
		self.awayMissed4ClickCommand = ScriptRelayCommand(self.script, self.AwayMissed4Action, lambda arg: True)
		self.awayMissed5ClickCommand = ScriptRelayCommand(self.script, self.AwayMissed5Action, lambda arg: True)
		
		self.newRoundClickCommand = ScriptRelayCommand(self.script, self.NewRoundAction, lambda arg: True)
		self.resetClickCommand = ScriptRelayCommand(self.script, self.ResetAction, lambda arg: True)
		self.showClickCommand = ScriptRelayCommand(self.script, self.ShowAction, lambda arg: True)
		self.outClickCommand = ScriptRelayCommand(self.script, self.OutAction, lambda arg: True)
		
		self.updateClickCommand = ScriptRelayCommand(self.script, self.UpdateAction, lambda arg: True)
		self.Penalties = []
		if self.Game:
			self.loadPenaltyEvents()

	def SetGame(self, game):
		try:
			self.Game = game
		except Exception as e:
			print "SetGame: %s" %str(e)
##############################################################################################
		
	@property 
	def HomeTeamName(self):
		return self.homeTeamName
		
	@HomeTeamName.setter
	def HomeTeamName(self, value):
		self.homeTeamName = value
		self.OnPropertyChanged("HomeTeamName")

	@property 
	def AwayTeamName(self):
		return self.awayTeamName
		
	@AwayTeamName.setter
	def AwayTeamName(self, value):
		self.awayTeamName = value
		self.OnPropertyChanged("AwayTeamName")

	@property 
	def Round1(self):
		return self.round1
		
	@Round1.setter
	def Round1(self, value):
		self.round1= value
		self.OnPropertyChanged("Round1")	

	@property 
	def Round2(self):
		return self.round2
		
	@Round2.setter
	def Round2(self, value):
		self.round2= value
		self.OnPropertyChanged("Round2")

	@property 
	def Round3(self):
		return self.round3
		
	@Round3.setter
	def Round3(self, value):
		self.round3= value
		self.OnPropertyChanged("Round3")

	@property 
	def Round4(self):
		return self.round4
		
	@Round4.setter
	def Round4(self, value):
		self.round4= value
		self.OnPropertyChanged("Round4")

	@property 
	def Round5(self):
		return self.round5
		
	@Round5.setter
	def Round5(self, value):
		self.round5= value
		self.OnPropertyChanged("Round5")	
	
	
	@property 
	def IsHomeStarting(self):
		return self.isHomeStarting
		
	@IsHomeStarting.setter
	def IsHomeStarting(self, value):
		self.isHomeStarting = value
		self.OnPropertyChanged("IsHomeStarting")
##############################################################################################

	@property 
	def HomeGoal1IsChecked(self):
		return self.homeGoal1IsChecked
		
	@HomeGoal1IsChecked.setter
	def HomeGoal1IsChecked(self, value):
		self.homeGoal1IsChecked = value
		self.OnPropertyChanged("HomeGoal1IsChecked")

	@property 
	def HomeGoal2IsChecked(self):
		return self.homeGoal2IsChecked
		
	@HomeGoal2IsChecked.setter
	def HomeGoal2IsChecked(self, value):
		self.homeGoal2IsChecked = value
		self.OnPropertyChanged("HomeGoal2IsChecked")

	@property 
	def HomeGoal3IsChecked(self):
		return self.homeGoal3IsChecked
		
	@HomeGoal3IsChecked.setter
	def HomeGoal3IsChecked(self, value):
		self.homeGoal3IsChecked = value
		self.OnPropertyChanged("HomeGoal3IsChecked")	
		
	@property 
	def HomeGoal4IsChecked(self):
		return self.homeGoal4IsChecked
		
	@HomeGoal4IsChecked.setter
	def HomeGoal4IsChecked(self, value):
		self.homeGoal4IsChecked = value
		self.OnPropertyChanged("HomeGoal4IsChecked")	
		
	@property 
	def HomeGoal5IsChecked(self):
		return self.homeGoal5IsChecked
		
	@HomeGoal5IsChecked.setter
	def HomeGoal5IsChecked(self, value):
		self.homeGoal5IsChecked = value
		self.OnPropertyChanged("HomeGoal5IsChecked")

##############################################################################################

	@property 
	def AwayGoal1IsChecked(self):
		return self.awayGoal1IsChecked
		
	@AwayGoal1IsChecked.setter
	def AwayGoal1IsChecked(self, value):
		self.awayGoal1IsChecked = value
		self.OnPropertyChanged("AwayGoal1IsChecked")	

	@property 
	def AwayGoal2IsChecked(self):
		return self.awayGoal2IsChecked
		
	@AwayGoal2IsChecked.setter
	def AwayGoal2IsChecked(self, value):
		self.awayGoal2IsChecked = value
		self.OnPropertyChanged("AwayGoal2IsChecked")

	@property 
	def AwayGoal3IsChecked(self):
		return self.awayGoal3IsChecked
		
	@AwayGoal3IsChecked.setter
	def AwayGoal3IsChecked(self, value):
		self.awayGoal3IsChecked = value
		self.OnPropertyChanged("AwayGoal3IsChecked")	
		
	@property 
	def AwayGoal4IsChecked(self):
		return self.awayGoal4IsChecked
		
	@AwayGoal4IsChecked.setter
	def AwayGoal4IsChecked(self, value):
		self.awayGoal4IsChecked = value
		self.OnPropertyChanged("AwayGoal4IsChecked")	

	@property 
	def AwayGoal5IsChecked(self):
		return self.awayGoal5IsChecked
		
	@AwayGoal5IsChecked.setter
	def AwayGoal5IsChecked(self, value):
		self.awayGoal5IsChecked = value
		self.OnPropertyChanged("AwayGoal5IsChecked")	

##############################################################################################

	@property 
	def HomeMissed1IsChecked(self):
		return self.homeMissed1IsChecked
		
	@HomeMissed1IsChecked.setter
	def HomeMissed1IsChecked(self, value):
		self.homeMissed1IsChecked = value
		self.OnPropertyChanged("HomeMissed1IsChecked")	

	@property 
	def HomeMissed2IsChecked(self):
		return self.homeMissed2IsChecked
		
	@HomeMissed2IsChecked.setter
	def HomeMissed2IsChecked(self, value):
		self.homeMissed2IsChecked = value
		self.OnPropertyChanged("HomeMissed2IsChecked")

	@property 
	def HomeMissed3IsChecked(self):
		return self.homeMissed3IsChecked
		
	@HomeMissed3IsChecked.setter
	def HomeMissed3IsChecked(self, value):
		self.homeMissed3IsChecked = value
		self.OnPropertyChanged("HomeMissed3IsChecked")	
		
	@property 
	def HomeMissed4IsChecked(self):
		return self.homeMissed4IsChecked
		
	@HomeMissed4IsChecked.setter
	def HomeMissed4IsChecked(self, value):
		self.homeMissed4IsChecked = value
		self.OnPropertyChanged("HomeMissed4IsChecked")	
		
	@property 
	def HomeMissed5IsChecked(self):
		return self.homeMissed5IsChecked
		
	@HomeMissed5IsChecked.setter
	def HomeMissed5IsChecked(self, value):	
		self.homeMissed5IsChecked = value
		self.OnPropertyChanged("HomeMissed5IsChecked")	

##############################################################################################

	@property 
	def AwayMissed1IsChecked(self):
		return self.awayMissed1IsChecked
		
	@AwayMissed1IsChecked.setter
	def AwayMissed1IsChecked(self, value):
		self.awayMissed1IsChecked = value
		self.OnPropertyChanged("AwayMissed1IsChecked")	

	@property 
	def AwayMissed2IsChecked(self):
		return self.awayMissed2IsChecked
		
	@AwayMissed2IsChecked.setter
	def AwayMissed2IsChecked(self, value):
		self.awayMissed2IsChecked = value
		self.OnPropertyChanged("AwayMissed2IsChecked")

	@property 
	def AwayMissed3IsChecked(self):
		return self.awayMissed3IsChecked
		
	@AwayMissed3IsChecked.setter
	def AwayMissed3IsChecked(self, value):	
		self.awayMissed3IsChecked = value
		self.OnPropertyChanged("AwayMissed3IsChecked")	
		
	@property 
	def AwayMissed4IsChecked(self):
		return self.awayMissed4IsChecked
		
	@AwayMissed4IsChecked.setter
	def AwayMissed4IsChecked(self, value):
		self.awayMissed4IsChecked = value
		self.OnPropertyChanged("AwayMissed4IsChecked")	

	@property 
	def AwayMissed5IsChecked(self):
		return self.awayMissed5IsChecked
		
	@AwayMissed5IsChecked.setter
	def AwayMissed5IsChecked(self, value):
		self.awayMissed5IsChecked = value
		self.OnPropertyChanged("AwayMissed5IsChecked")

##############################################################################################

	@property
	def HomeGoal1ClickCommand(self):
		return self.homeGoal1ClickCommand

	def HomeGoal1Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.HomeTeam, "Home", "1", args2[0])
		except Exception as e:
			print "HomeGoal1Action: %s" %str(e)

	@property
	def HomeGoal2ClickCommand(self):
		return self.homeGoal2ClickCommand

	def HomeGoal2Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.HomeTeam, "Home", "2", args2[0])
		except Exception as e:
			print "HomeGoal2Action: %s" %str(e)

	@property
	def HomeGoal3ClickCommand(self):
		return self.homeGoal3ClickCommand

	def HomeGoal3Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.HomeTeam, "Home", "3", args2[0])
		except Exception as e:
			print "HomeGoal3Action: %s" %str(e)

	@property
	def HomeGoal4ClickCommand(self):
		return self.homeGoal4ClickCommand

	def HomeGoal4Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.HomeTeam, "Home", "4", args2[0])
		except Exception as e:
			print "HomeGoal4Action: %s" %str(e)

	@property
	def HomeGoal5ClickCommand(self):
		return self.homeGoal5ClickCommand

	def HomeGoal5Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.HomeTeam, "Home", "5", args2[0])
		except Exception as e:
			print "HomeGoal5Action: %s" %str(e)

##############################################################################################

	@property
	def AwayGoal1ClickCommand(self):
		return self.awayGoal1ClickCommand

	def AwayGoal1Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.AwayTeam, "Away", "1", args2[0])
		except Exception as e:
			print "AwayGoal1Action: %s" %str(e)

	@property
	def AwayGoal2ClickCommand(self):
		return self.awayGoal2ClickCommand

	def AwayGoal2Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.AwayTeam, "Away", "2", args2[0])
		except Exception as e:
			print "AwayGoa21Action: %s" %str(e)

	@property
	def AwayGoal3ClickCommand(self):
		return self.awayGoal3ClickCommand

	def AwayGoal3Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.AwayTeam, "Away", "3", args2[0])
		except Exception as e:
			print "AwayGoal3Action: %s" %str(e)

	@property
	def AwayGoal4ClickCommand(self):
		return self.awayGoal4ClickCommand

	def AwayGoal4Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.AwayTeam, "Away", "4", args2[0])
		except Exception as e:
			print "AwayGoal4Action: %s" %str(e)

	@property
	def AwayGoal5ClickCommand(self):
		return self.awayGoal5ClickCommand 

	def AwayGoal5Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__GoalAction(self.Game.AwayTeam, "Away", "5", args2[0])
		except Exception as e:
			print "AwayGoal5Action: %s" %str(e)

##############################################################################################

	@property
	def HomeMissed1ClickCommand(self):
		return self.homeMissed1ClickCommand

	def HomeMissed1Action(self, param=None, args1 = None, args2 = None):		
		try:
			self.__MissedAction(self.Game.HomeTeam, "Home", "1", args2[0])			
		except Exception as e:
			print "HomeMissed1Action: %s" %str(e)

	@property
	def HomeMissed2ClickCommand(self):
		return self.homeMissed2ClickCommand

	def HomeMissed2Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.HomeTeam, "Home", "2", args2[0])
		except Exception as e:
			print "HomeMissed2Action: %s" %str(e)

	@property
	def HomeMissed3ClickCommand(self):
		return self.homeMissed3ClickCommand

	def HomeMissed3Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.HomeTeam, "Home", "3", args2[0])
		except Exception as e:
			print "HomeMissed3Action: %s" %str(e)

	@property
	def HomeMissed4ClickCommand(self):
		return self.homeMissed4ClickCommand

	def HomeMissed4Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.HomeTeam, "Home", "4", args2[0])
		except Exception as e:
			print "HomeMissed4Action: %s" %str(e)

	@property
	def HomeMissed5ClickCommand(self):
		return self.homeMissed5ClickCommand

	def HomeMissed5Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.HomeTeam, "Home", "5", args2[0])
		except Exception as e:
			print "HomeMissed5Action: %s" %str(e)
		
##############################################################################################

	@property
	def AwayMissed1ClickCommand(self):
		return self.awayMissed1ClickCommand

	def AwayMissed1Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.AwayTeam, "Away", "1", args2[0])
		except Exception as e:
			print "AwayMissed1Action: %s" %str(e)

	@property
	def AwayMissed2ClickCommand(self):
		return self.awayMissed2ClickCommand

	def AwayMissed2Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.AwayTeam, "Away", "2", args2[0])
		except Exception as e:
			print "AwayMissed2Action: %s" %str(e)

	@property
	def AwayMissed3ClickCommand(self):
		return self.awayMissed3ClickCommand

	def AwayMissed3Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.AwayTeam, "Away", "3", args2[0])
		except Exception as e:
			print "AwayMissed3Action: %s" %str(e)

	@property
	def AwayMissed4ClickCommand(self):
		return self.awayMissed4ClickCommand

	def AwayMissed4Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.AwayTeam, "Away", "4", args2[0])
		except Exception as e:
			print "AwayMissed4Action: %s" %str(e)

	@property
	def AwayMissed5ClickCommand(self):
		return self.awayMissed5ClickCommand

	def AwayMissed5Action(self, param=None, args1 = None, args2 = None):
		try:
			self.__MissedAction(self.Game.AwayTeam, "Away", "5", args2[0])
		except Exception as e:
			print "AwayMissed5Action: %s" %str(e)

##############################################################################################

	@property
	def NewRoundClickCommand(self):
		return self.newRoundClickCommand

	def NewRoundAction(self, param=None, args1 = None, args2 = None):
		try:
			for i in range(5, 0, -1):
				if not ((getattr(self, "HomeGoal%sIsChecked" %i) or getattr(self, "HomeMissed%sIsChecked" %i)) and (getattr(self, "AwayGoal%sIsChecked" %i) or getattr(self, "AwayMissed%sIsChecked" %i))):
					self.appCore.StatusManager.Add("Fill all rounds before create a new one!")
					return False
					
			if not self.appCore.UserIteraction.ShowMessageBoxYesNo("NEW ROUND", "CREATE NEW ROUND?").ToString() == "Yes": return
			
			for i in range(1, 6):
				setattr(self, "Round%s" %i, (getattr(self, "Round%s" %i) + 5))
			
			for i in range(5, 0, -1):
				setattr(self, "HomeGoal%sIsChecked" %i, False)
				setattr(self, "HomeMissed%sIsChecked" %i, False)
				setattr(self, "AwayGoal%sIsChecked" %i, False)
				setattr(self, "AwayMissed%sIsChecked" %i, False)
		except Exception as e:
			print "NewRoundAction: %s" %str(e)
				
	@property
	def ResetClickCommand(self):
		return self.resetClickCommand

	def ResetAction(self, param=None, args1 = None, args2 = None):
		try:
			if not self.appCore.UserIteraction.ShowMessageBoxYesNo("RESET", "RESET PENALTYS!\n\nCONTINUE ANYWAY?").ToString() == "Yes": return
			configurations = {
				"Round1": 1,
				"Round2": 2,
				"Round3": 3,
				"Round4": 4,
				"Round5": 5,
				"HomeGoal1IsChecked": False,
				"HomeGoal2IsChecked": False,
				"HomeGoal3IsChecked": False,
				"HomeGoal4IsChecked": False,
				"HomeGoal5IsChecked": False,
				"HomeMissed1IsChecked": False,
				"HomeMissed2IsChecked": False,
				"HomeMissed3IsChecked": False,
				"HomeMissed4IsChecked": False,
				"HomeMissed5IsChecked": False,
				"AwayGoal1IsChecked": False,
				"AwayGoal2IsChecked": False,
				"AwayGoal3IsChecked": False,
				"AwayGoal4IsChecked": False,
				"AwayGoal5IsChecked": False,
				"AwayMissed1IsChecked": False,
				"AwayMissed2IsChecked": False,
				"AwayMissed3IsChecked": False,
				"AwayMissed4IsChecked": False,
				"AwayMissed5IsChecked": False,
				
			}
	
			penaltyEvents = filter(lambda event: event.Event and event.Name == "Penalty", self.Game.OrderedGameEvents)
			self.Game.DeleteGameEvents(penaltyEvents)
			for configuration in configurations:
				setattr(self, configuration, configurations[configuration])
				
			graphic = GraphicTemplatesManager.GetGraphicByName("PENALTIES")
			if not graphic: return
			if not IntelliflowController.GetGraphicOnAirItems(graphic, OutputManager.ActiveChannelOutput):return
			
			Project.ExecuteScript(graphic.Script, "__updatePenalties")
		except Exception as e:
			print "ResetAction: %s" %str(e)

	@property
	def ShowClickCommand(self):
		return self.showClickCommand

	def ShowAction(self, param=None, args1 = None, args2 = None):
		graphic = GraphicTemplatesManager.GetGraphicByName("PENALTIES")
		
		if not graphic: return
		
		if IntelliflowController.GetGraphicOnAirItems(graphic, OutputManager.ActiveChannelOutput):
			self.appCore.StatusManager.Add("Graphic is OnAir!")
			return

		IntelliflowController.TakeIn(graphic, OutputManager.ActiveChannelOutput, workflowType = IntelliflowController.EWorkflowType.Preview if graphic.Preview else IntelliflowController.EWorkflowType.Program)
	
	@property
	def UpdateClickCommand(self):
		return self.updateClickCommand

	def UpdateAction(self, param=None, args1 = None, args2 = None):
		graphic = GraphicTemplatesManager.GetGraphicByName("PENALTIES")
		
		if not graphic: return
		if not IntelliflowController.GetGraphicOnAirItems(graphic, OutputManager.ActiveChannelOutput):return
		Project.ExecuteScript(graphic.Script, "__updatePenalties")
	
		
	@property
	def OutClickCommand(self):
		return self.outClickCommand

	def OutAction(self, param=None, args1 = None, args2 = None):
		graphic = GraphicTemplatesManager.GetGraphicByName("PENALTIES")
		
		if not graphic: return

		IntelliflowController.TakeOut(graphic, OutputManager.ActiveChannelOutput)

	def validateShootouts(self, number):
		for i in range(1, number):
			if not getattr(self, "homeGoal%sIsChecked" %i) and not getattr(self, "homeMissed%sIsChecked" %i):
				self.appCore.StatusManager.Add("Round %s for Home Team is not valid!" %i)
				return False

			if not getattr(self, "awayGoal%sIsChecked" %i) and not getattr(self, "awayMissed%sIsChecked" %i):
				self.appCore.StatusManager.Add("Round %s for Away Team is not valid!" %i)
				return False

		return True
	
	def loadPenaltyEvents(self):
		try:
			event = FootballEvents.Penalty
			homeTeamPenalties = 1
			awayTeamPenalties = 1
			orderedGameEvents = self.Game.OrderedGameEvents
			homeGameEvents = filter(lambda item: item.Event == event and item.Team == self.Game.HomeTeam, list(orderedGameEvents))
			awayGameEvents = filter(lambda item: item.Event == event and item.Team == self.Game.AwayTeam, list(orderedGameEvents))
			homeRes = int(homeGameEvents.Count % 5) if int(homeGameEvents.Count % 5) != 0 else 5
			awayRes = int(awayGameEvents.Count % 5) if int(awayGameEvents.Count % 5) != 0 else 5
				
			for gameEvent in homeGameEvents[-homeRes:]:
				eventAttr = next((item for item in list(gameEvent.Attributes) if (item.Name == FootballEventAttributes.PenaltyKickResult.Name)), None)
				if eventAttr:
					if eventAttr.Value == EPenaltyKickResult.Goal.ToString():
						setattr(self, "HomeGoal%sIsChecked"%homeTeamPenalties, True)
					elif eventAttr.Value == EPenaltyKickResult.Other.ToString():
						setattr(self, "HomeMissed%sIsChecked"%homeTeamPenalties, True)	
						
					homeTeamPenalties += 1
				
			for gameEvent in awayGameEvents[-awayRes:]:	
				eventAttr = next((item for item in list(gameEvent.Attributes) if (item.Name == FootballEventAttributes.PenaltyKickResult.Name)), None)
				if eventAttr:
					if eventAttr.Value == EPenaltyKickResult.Goal.ToString():
						setattr(self, "AwayGoal%sIsChecked"%awayTeamPenalties, True)
					elif eventAttr.Value == EPenaltyKickResult.Other.ToString():
						setattr(self, "AwayMissed%sIsChecked"%awayTeamPenalties, True)	
						
					awayTeamPenalties += 1
			
			maxEvents = max(homeGameEvents.Count, awayGameEvents.Count)
			round = (int(maxEvents / 5) + 1) * 5
			
			for enum, i in enumerate(reversed(range(round, round - 5, -1))):
				setattr(self, "Round%s" % (enum+1), i)
		except Exception as e:
			print "loadPenaltyEvents: %s" %str(e)

	def __GoalAction(self, team, propertyTeam, propertyNumber, eventNumber):
		try:
			print propertyNumber
			print self.isHomeStarting
			print team.IsHomeTeam
			if propertyNumber == 1 and (self.isHomeStarting == True) and not team.IsHomeTeam:
				self.appCore.StatusManager.Add("Home team is starting!")
				isChecked = getattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber))
				setattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber), False if isChecked else True)
				return
				
			if not self.Game.Clock.ActivePart.Number == 9:
				self.appCore.StatusManager.Add("You're not on Penalties part!")
				isChecked = getattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber))
				setattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber), False if isChecked else True)
				return
				
			if not self.validateShootouts(int(propertyNumber)):
				isChecked = getattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber))
				setattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber), False if isChecked else True)
				return
			
			event = FootballEvents.Penalty			
			gamePart = self.Game.Clock.ActivePart.Number
			time = TimeSpan(0, int(eventNumber), 0)		
			goalChecked = getattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber))
			missedChecked = getattr(self, "%sMissed%sIsChecked"%(propertyTeam, propertyNumber))
	
			if goalChecked: #creates a new penalty event
				if missedChecked:
					setattr(self, "%sMissed%sIsChecked"%(propertyTeam, propertyNumber), False)
				
					orderedGameEvents = self.Game.OrderedGameEvents
					gameEvents = filter(lambda item: item.Event == event and item.Team == team, list(orderedGameEvents))
					gameEvent = gameEvents[int(eventNumber) - 1]
					
					eventAttr = next((item for item in list(gameEvent.Attributes) if (item.Name == FootballEventAttributes.PenaltyKickResult.Name)), None)
					if eventAttr and eventAttr.Value == EPenaltyKickResult.Other.ToString():
						eventAttr.Value = EPenaltyKickResult.Goal.ToString()					
						self.Game.UpdateGameEvent(gameEvent)
				else:
					penaltyValueTuple = ValueTuple.Create(FootballEventAttributes.PenaltyKickResult.Name, EPenaltyKickResult.Goal.ToString())
					gameEvent = self.Game.AddEvent(event, gamePart, time, team, None, None, None, None, [penaltyValueTuple])
					
			else: #delete penalty event
				orderedGameEvents = self.Game.OrderedGameEvents				
				#gameEvent = next((item for item in reversed(list(orderedGameEvents)) if (item.Event == event and item.Team == team)), None)
				gameEvents = filter(lambda item: item.Event == event and item.Team == team, list(orderedGameEvents))
				gameEvent = gameEvents[int(eventNumber) - 1]
				
				if gameEvent:
					self.Game.DeleteGameEvent(gameEvent)
		except Exception as e:
			print "__GoalAction: %s" %str(e)

	def __MissedAction(self, team, propertyTeam, propertyNumber, eventNumber):
		try: 
			if propertyNumber == 1 and self.isHomeStarting == True and not team.IsHomeTeam:
				self.appCore.StatusManager.Add("Home team is starting!")
				isChecked = getattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber))
				setattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber), False if isChecked else True)
				return
				
			if not self.Game.Clock.ActivePart.Number == 9:
				self.appCore.StatusManager.Add("You're not on Penalties part!")
				isChecked = getattr(self, "%sMissed%sIsChecked"%(propertyTeam, propertyNumber))
				setattr(self, "%sMissed%sIsChecked"%(propertyTeam, propertyNumber), False if isChecked else True)
				return

			if not self.validateShootouts(int(propertyNumber)):
				isChecked = getattr(self, "%sMissed%sIsChecked"%(propertyTeam, propertyNumber))
				setattr(self, "%sMissed%sIsChecked"%(propertyTeam, propertyNumber), False if isChecked else True)
				return
			
			event = FootballEvents.Penalty
			gamePart = self.Game.Clock.ActivePart.Number
			time = TimeSpan(0, int(eventNumber), 0) 
			goalChecked = getattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber))
			missedChecked = getattr(self, "%sMissed%sIsChecked"%(propertyTeam, propertyNumber))
			
			if missedChecked:
				if goalChecked:
					setattr(self, "%sGoal%sIsChecked"%(propertyTeam, propertyNumber), False)
					
					orderedGameEvents = self.Game.OrderedGameEvents
					gameEvents = filter(lambda item: item.Event == event and item.Team == team,list(orderedGameEvents))
					gameEvent = gameEvents[int(eventNumber) - 1]
					eventAttr = next((item for item in list(gameEvent.Attributes) if (item.Name == FootballEventAttributes.PenaltyKickResult.Name)), None)
					
					if eventAttr and eventAttr.Value == EPenaltyKickResult.Goal.ToString():
						eventAttr.Value = EPenaltyKickResult.Other.ToString()					
						self.Game.UpdateGameEvent(gameEvent)
				else:
					penaltyValueTuple = ValueTuple.Create(FootballEventAttributes.PenaltyKickResult.Name, EPenaltyKickResult.Other.ToString())
					gameEvent = self.Game.AddEvent(event, gamePart, time, team, None, None, None, None, [penaltyValueTuple])		
					
			else: #delete penalty event
				orderedGameEvents = self.Game.OrderedGameEvents				
				gameEvents = filter(lambda item: item.Event == event and item.Team == team, list(orderedGameEvents))
				
				gameEvent = gameEvents[int(eventNumber) - 1]				
				if gameEvent:
					self.Game.DeleteGameEvent(gameEvent)		
					
		except Exception as e:
			print "__MissedAction: %s" %str(e)