import clr
clr.AddReference("Wtvision.Sports.Tools.UefaDigitalAPIImporter")
from Wtvision.Sports import UefaDigitalApiProxy
from System.Collections import Hashtable 
from System import Array, DateTime
from System.Threading.Tasks import Task
from Wtvision.Sports.Uefa import EventTypes
import smartpaging
import helper

Stats = ["ball_possession", "attempts_on_target", "attempts", "corners", "fouls_suffered"]

def __beforeProgram(graphicOnAirItem, momentExecution):
	extradata = graphicOnAirItem.ExtraData
	helper.GraphicTakeIn("ScoreWithScorers_OtherMatches", GraphicTemplatesManager, OutputManager, IntelliflowController, extradata = extradata) 
	graphicOnAirItem.Scene.Show("Substitutes_to_Statistics")


def updateGames(extradata):
	matches = UefaDigitalApiProxy.GetMatches(offset= "0",limit = "500",competitionId = Array[str]([Game.Competition.IdCompetition]),matchDayId = Array[str]([matchDayId]))
	matches = sorted(matches, key=lambda match: match.KickOffTime.DateTime)
	
	matches = [match for match in matches if match.Type.ToString().upper() == leg] ## ONLY LEG GAMES
#		current_date = DateTime.Today.AddDays(-3)
	current_date = __getMyMatch()

	matches = matches = [match for match in matches if match.KickOffTime.Date == current_date.KickOffTime.Date] # JUST FOR TODAY GAMES
	#matches = filter(lambda match: match.Id != Game.ExternalId, matches) # REMOVE THE ATIVE GAME
	#matches_live = [match for match in matches if match.Status.ToString().upper() == "LIVE"] # JUST FOR LIVE GAMES
	matches_live = matches 
	matches_finished = [match for match in matches if match.Status.ToString().upper() == "FINISHED"] 
	matches_upcoming = [match for match in matches if match.Status.ToString().upper() == "UPCOMING"] 
	
	
	#games_to_show = smartpaging.NonUniformPaging(len(matches_live), 9)
	
	
	##ONLY FOR 18 GAMES LIVE
	games=[]
	games.append(matches[0:9])
	games.append(matches[9:18])

	
	len_matches = len(matches)# if len(matches) <= 9 else 9
			
	helper.SetExtraData(extradata, "total", len_matches)#len(matches_live) + len(matches_finished))
	helper.SetExtraData(extradata, "index", 0)#len(matches_finished))
	helper.SetExtraData(extradata, "pageIndex", 0)#len(matches) - (len(matches_live) + len(matches_upcoming)))
	helper.SetExtraData(extradata, "pages", (smartpaging.NonUniformPaging(len_matches, 1))) 
	helper.SetExtraData(extradata, "allMatches", matches)
	helper.SetExtraData(extradata, "matchesToBottom", matches)
	helper.SetExtraData(extradata, "allMatchesLive", matches_live)
	helper.SetExtraData(extradata, "games", games)



def __onStart(graphicOnAirItem, momentExecution, workFlowtype):

	
	extradata = graphicOnAirItem.ExtraData
	
	if not extradata.ContainsKey("ExternalTake"):
		helper.SetExtraData(extradata, "ExternalTake", "True")

	competitionId = Game.Competition.IdCompetition
	matchDayId =  Game.Attributes["MatchDayId"] 

	### METHOD TO GET ACTUAL LEG
	matchId = Game.ExternalId
	active_game_events = UefaDigitalApiProxy.GetMatch(matchId = matchId)
	leg = active_game_events.Type.ToString().upper()
	### END
	
	if extradata["ExternalTake"] == "True":
		
		updateGames(graphicOnAirItem.ExtraData)
	
		if len(matches) == 0:
			momentExecution.MessageType = momentExecution.MessageType.Info
			momentExecution.Message = "LINEUP AND STATS OTHER MATCHES: No matches found!"
			momentExecution.Cancel = True
			return
		
		if len(matches) == 1:
			momentExecution.MessageType = momentExecution.MessageType.Info
			momentExecution.Message = "LINEUP AND STATS OTHER MATCHES: Only 1 match live!"
			momentExecution.Cancel = True
			return

		return
		
def __getMyMatch():
	"""Get My Match
		Parameters:
			team: Wtvision.Sports.Team
		Returns:
			bool:Returns match array for Today
	"""
	competitionId = Game.Competition.IdCompetition
	matchDayId = Game.Attributes["MatchDayId"] 
	matches = UefaDigitalApiProxy.GetMatches(offset= "0",limit = "500",competitionId = Array[str]([Game.Competition.IdCompetition]),matchDayId = Array[str]([matchDayId]))
	matchId = Game.ExternalId
	mygame = next(iter([match for match in matches if match.Id == matchId]), None) # Get myGame
	if not mygame:
		#No Data
		return None
	#matches = sorted(matches, key=lambda match: match.KickOffTime.DateTime)# No need just games for today

	return mygame # JUST GAMES  IN THE SAME DAY OF MY GAME
	
def __getCards(matchId):
	game_events = UefaDigitalApiProxy.GetMatchEvents(matchId = matchId, filter = EventTypes.CARDS, offset= "0",limit = "500")
	result = {}
	for event in game_events:
		if hasattr(event.PrimaryActor.Person, "Id"):
			result[event.PrimaryActor.Person.Id] = str(event.Type)
	return result
	
def __getData(graphicOnAirItem, viewBag, momentExecution):
	#try:
	__clearTags(viewBag)

	extradata = graphicOnAirItem.ExtraData
	competitionId = Game.Competition.IdCompetition
	matchDayId =  Game.Attributes["MatchDayId"]
	index = extradata["index"]
	pageIndex = extradata["pageIndex"]
	pages = extradata["pages"]

	if pageIndex > len(pages):
		momentExecution.MessageType = momentExecution.MessageType.Info
		momentExecution.Message = "No RESULTS to show."
		momentExecution.Cancel = True
		return 
	
	pageEnd = pages[pageIndex]
	allMatches = extradata["allMatches"]
	matchesToBottom = extradata["matchesToBottom"]
	allMatchesLive = extradata["allMatchesLive"]
	match = allMatches[pageIndex]

	helper.SetExtraData(extradata, "match", match) ## info for score with scorers
	
	matchId = match.Id
	lineUp = UefaDigitalApiProxy.GetMatchLineups(matchId = match.Id)
	print "---------------------------------------- /START FILL/ --------------------------------------------------------------------------------"
	for tagName in ["Home", "Away"]:
		if tagName == "Home":
			__FillTeamData(lineUp.HomeTeam, viewBag,tagName,matchId)	
			viewBag.SetString("t{TeamTag}BottomTeamHighlight".format(TeamTag=tagName), match.HomeTeam.TeamCode.ToString().upper())
			
		else:
			__FillTeamData(lineUp.AwayTeam, viewBag,tagName,matchId)
			viewBag.SetString("t{TeamTag}BottomTeamHighlight".format(TeamTag=tagName), match.AwayTeam.TeamCode.ToString().upper())
	print "---------------------------------------- /END FILL/ --------------------------------------------------------------------------------"	
	########## FILL BOTTOM INFORMATION
	viewBag.SetFloat("vBottomGames", len(matchesToBottom))
	
	__fillBottomInformation(graphicOnAirItem, viewBag, matchesToBottom)
	#print "teste"
	game_stats = UefaDigitalApiProxy.GetTeamStatistic(matchId = match.Id)
	__fill_stats(viewBag, game_stats)
	
	########### FILL LINEUPS
	lineUp = UefaDigitalApiProxy.GetMatchLineups(matchId = match.Id)
	
	helper.SetExtraData(extradata, "ExternalTake", "True")
	helper.SetExtraData(extradata, "index", index + int(pageEnd))
	helper.SetExtraData(extradata, "pageIndex", pageIndex+1)
	helper.SetExtraData(extradata, "lenAllMatchesLive", len(allMatchesLive))
	
	
	__updateSubstitutions(viewBag, matchId,lineUp)
#	except Exception as e:
#		momentExecution.Message ="ERROR LINEUP_STATS_ALLMATCHES: %s" % str(e)
#		momentExecution.MessageType = momentExecution.MessageType.Warning
#		momentExecution.Cancel = True
#		return	
	
def __FillTeamData(team, viewBag,tagName,matchId):
		##GET Cards For Match
	cards = __getCards(matchId)
	print "TagName --> %s"%tagName
	print "team--->%s"%team
	## HOME LINEUP
	if hasattr(team, "Coaches") and len(team.Coaches) > 0:
		viewBag.SetTranslatedText("t{teamTag}CoachFunction".format(teamTag=tagName), "{{%s}}.{{LineUp}}|filter:ToUpper " % team.Coaches[0].Role)
		if "EN" in team.Coaches[0].Person.Translations.ShortName:
#			viewBag.SetString("tHomeCoachFirstName", lineUp.HomeTeam.Coaches[0].Person.Translations.FirstName["EN"].ToString().upper())
			viewBag.SetString("t{teamTag}CoachLastName".format(teamTag=tagName) , team.Coaches[0].Person.Translations.ShortName["EN"].ToString().upper())
		viewBag.SetString("v{teamTag}CoachCard".format(teamTag=tagName), 0)
	
	for enum,player in enumerate(team.Field):
		viewBag.SetVisibility("v{teamTag}SubstitutionVisibility%02d".format(teamTag=tagName) % (enum+1), False)
		viewBag.SetString("t{teamTag}Number%02d".format(teamTag=tagName) % (enum+1), player.JerseyNumber.ToString())
		if player.Player.Id in cards.keys():
			viewBag.SetVisibility("v{teamTag}AtRiskVisibility%02d".format(teamTag=tagName) % (enum+1), True)
			viewBag.SetFloat("v{teamTag}Card%02d".format(teamTag=tagName) % (enum+1), 1 if cards[player.Player.Id]=="YELLOW_CARD" else 2)
		else:
			viewBag.SetFloat("v{teamTag}Card%02d".format(teamTag=tagName) % (enum+1), 0)

#		if "EN" in player.Player.Translations.FirstName:
#			viewBag.SetString("tHomeName%02d" % (enum+1), player.Player.Translations.FirstName["EN"].ToString().upper())
		if hasattr(player.Player.Translations, "ShortName"):
			viewBag.SetString("t{teamTag}LastName%02d".format(teamTag=tagName) % (enum+1), player.Player.Translations.ShortName["EN"].ToString().upper())

def __updateSubstitutions(viewBag, matchId, lineUp):

	home_team_id = lineUp.HomeTeam.Team.Id.ToString()
	away_team_id = lineUp.AwayTeam.Team.Id.ToString()
	
	substitution_events_home = []
	substitution_events_away = []
	
	game_events = UefaDigitalApiProxy.GetMatchEvents(matchId = matchId, filter = EventTypes.LINEUP, offset= "0",limit = "500")
	substitution_events = filter(lambda sub_event: sub_event.Type.ToString().upper() == "SUBSTITUTION", game_events) # FILTER TO SHOW ONLY SUBSTITUTION EVENTS
	substitution_events_home = filter(lambda sub: sub.PrimaryActor.Team.Id.ToString() == home_team_id, substitution_events) 
	substitution_events_away = filter(lambda sub: sub.PrimaryActor.Team.Id.ToString() == away_team_id, substitution_events) 

	if len(substitution_events_home) >= 5:
		viewBag.SetFloat("vHomeSubstitutes", 5)
	else:
		viewBag.SetFloat("vHomeSubstitutes", len(substitution_events_home))

	if len(substitution_events_away) >= 5:
		viewBag.SetFloat("vAwaySubstitutes", 5)
	else:
		viewBag.SetFloat("vAwaySubstitutes", len(substitution_events_away))

	if substitution_events_home > 0:
		for enum, sub_event in enumerate(substitution_events_home):
			player_home_id = sub_event.PrimaryActor.Person.Id
			index = next((i for i,x in enumerate(lineUp.HomeTeam.Field,1) if player_home_id == x.Player.Id), None)
			if index:
				viewBag.SetVisibility("vHomeSubstitutionVisibility%02d" % index, True)
			if "EN" in sub_event.SecondaryActor.Person.Translations.ShortName:
#				viewBag.SetString("tHomeSubstitutionName%02d" % (enum+1), sub_event.SecondaryActor.Person.Translations.FirstName["EN"].ToString().upper())
				viewBag.SetString("tHomeSubstitutionLastName%02d" % (enum+1), sub_event.SecondaryActor.Person.Translations.ShortName["EN"].ToString().upper())
		
	if substitution_events_away > 0:
		for enum, sub_event in enumerate(substitution_events_away):
			player_away_id = sub_event.PrimaryActor.Person.Id
			index = next((i for i,x in enumerate(lineUp.AwayTeam.Field,1) if player_away_id == x.Player.Id), None)
			if index:
				viewBag.SetVisibility("vAwaySubstitutionVisibility%02d" % index, True)
			if "EN" in sub_event.SecondaryActor.Person.Translations.ShortName:
#				viewBag.SetString("tAwaySubstitutionName%02d" % (enum+1), sub_event.SecondaryActor.Person.Translations.FirstName["EN"].ToString().upper())
				viewBag.SetString("tAwaySubstitutionLastName%02d" % (enum+1), sub_event.SecondaryActor.Person.Translations.ShortName["EN"].ToString().upper())

def __fillBottomInformation(graphicOnAirItem, viewBag, allMatches):
	extradata = graphicOnAirItem.ExtraData

	index = extradata["index"]
	games = extradata["games"]
	
	#print index
	
	if int(index) <= 8:
		allMatches = games[0]
		highlightIndex = index
	else:
		highlightIndex = int(index) - 9
		allMatches = games[1]
		
	for enum, matchBottom in enumerate(allMatches):
		viewBag.SetString("tHomeBottomTeam%02d" % (enum+1), matchBottom.HomeTeam.TeamCode.ToString().upper())
		viewBag.SetString("tAwayBottomTeam%02d" % (enum+1), matchBottom.AwayTeam.TeamCode.ToString().upper())
		
		status = matchBottom.Status.ToString().upper()
		if status == "FINISHED":
			if hasattr(matchBottom.Score, "Total"):
				result = "%s - %s" % (matchBottom.Score.Total.Home, matchBottom.Score.Total.Away)
				viewBag.SetString("tBottomTime%02d" % (enum+1), result)
			else:
				result = "%s - %s" % (matchBottom.Score.Regular.Home, matchBottom.Score.Regular.Away)
				viewBag.SetString("tBottomTime%02d" % (enum+1), result)
		elif status == "LIVE":
			if hasattr(matchBottom.Score, "Total"):
				result = "(%s - %s)" % (matchBottom.Score.Total.Home, matchBottom.Score.Total.Away)
				viewBag.SetString("tBottomTime%02d" % (enum+1), result)
			else:
				result = "(%s - %s)" % (matchBottom.Score.Regular.Home, matchBottom.Score.Regular.Away)
				viewBag.SetString("tBottomTime%02d" % (enum+1), result)
		elif status == "UPCOMING":
			date = matchBottom.KickOffTime.DateTime.ToLocalTime()
			hour_minute = "%sH%02d" % (date.Hour, date.Minute)
			viewBag.SetTranslatedText("tGameInfo%02d" % enum, "{{%s}}.{{AggregateSummaryResults}}" % date)
			viewBag.SetString("tBottomTime%02d" % (enum+1), "%s" % hour_minute)
			
	match_to_highlight = allMatches[highlightIndex]
	viewBag.SetVisibility("vHighlightVisibility", True)
	viewBag.SetFloat("vBottomHighlight", highlightIndex+1)
	viewBag.SetString("tHomeBottomTeamHighlight", match_to_highlight.HomeTeam.TeamCode.ToString().upper())
	viewBag.SetString("tAwayBottomTeamHighlight", match_to_highlight.AwayTeam.TeamCode.ToString().upper())

	if hasattr(match_to_highlight.Score, "Total"):
		result = "(%s - %s)" % (match_to_highlight.Score.Total.Home, match_to_highlight.Score.Total.Away)
		viewBag.SetString("tBottomTimeHighlight", result)
	elif hasattr(match_to_highlight.Score, "Score"):
		result = "(%s - %s)" % (match_to_highlight.Score.Regular.Home, match_to_highlight.Score.Regular.Away)
		viewBag.SetString("tBottomTimeHighlight", result)
	else: 
		viewBag.SetString("tBottomTimeHighlight", "(%s - %s)"%(0,0))
	

def __fill_stats(viewBag, game_stats):
	### HOME STATS
	filtered_stats_home = []
	if not len(game_stats):
		for tag in range(1,6):
			viewBag.SetString("tHomeStatName%02d" % (tag), "")			
			viewBag.SetString("tHomeStatValue%02d" % (tag), "")
			viewBag.SetString("tAwayStatName%02d" % (tag), "")
			viewBag.SetString("tAwayStatValue%02d" % (tag),"")
		return;
	
	for stat in game_stats[1].Statistics:
		if stat.Name in Stats:
			stat_name = stat.Name
			stat_value = stat.Value
			filtered_stats_home.append((stat_name, stat_value))

	for enum, stat in enumerate(filtered_stats_home):
		if stat[0].ToString().lower() == "ball_possession":
			viewBag.SetTranslatedText("tHomeStatName%02d" % (enum+1), "{{%s}}.{{LineUp_Stat}}|filter:ToUpper " % "possession")			
			viewBag.SetString("tHomeStatValue%02d" % (enum+1), "%s%%" % stat[1])
		else:
			viewBag.SetTranslatedText("tHomeStatName%02d" % (enum+1), "{{%s}}.{{LineUp_Stat}}|filter:ToUpper " % stat[0])
			viewBag.SetString("tHomeStatValue%02d" % (enum+1), stat[1])

	### AWAY STATS
	filtered_stats_away = []
	for stat in game_stats[0].Statistics:
		if stat.Name in Stats:
			stat_name = stat.Name
			stat_value = stat.Value
			filtered_stats_away.append((stat_name, stat_value))

	for enum, stat in enumerate(filtered_stats_away):
		if stat[0].ToString().lower() == "ball_possession":
			viewBag.SetTranslatedText("tAwayStatName%02d" % (enum+1), "{{%s}}.{{LineUp_Stat}}|filter:ToUpper " % "possession")
			viewBag.SetString("tAwayStatValue%02d" % (enum+1), "%s%%" % stat[1])
		else:
			viewBag.SetTranslatedText("tAwayStatName%02d" % (enum+1), "{{%s}}.{{LineUp_Stat}}|filter:ToUpper " % stat[0])
			viewBag.SetString("tAwayStatValue%02d" % (enum+1), stat[1])

def __afterProgram(graphicOnAirItem, momentExecution):	

	#extradata = graphicOnAirItem.ExtraData
	updateGames(graphicOnAirItem.ExtraData)
	pages = extradata["pages"]
	lenAllMatchesLive = extradata["lenAllMatchesLive"]
	delay = int(Project.ProjectSettings["OnAirTimeOtherMatches (ms)"]) / int(lenAllMatchesLive)
	Task.Delay(int(delay)).ContinueWith(lambda x: __continueGraphic(graphicOnAirItem, momentExecution))
	helper.SetExtraData(extradata, "ExternalTake", "False")

def __continueGraphic(graphicOnAirItem, momentExecution):
	extradata = graphicOnAirItem.ExtraData
	index = extradata["index"]
	total = extradata["total"]
	pages = extradata["pages"]
		
	if index < total:
		helper.SetExtraData(extradata, "NextPage", "True")
		IntelliflowController.TakeInNextPage(graphicOnAirItem.Graphic, OutputManager.ActiveChannelOutput, workflowType=IntelliflowController.EWorkflowType.Program, )
	else:
		Scheduler.ClearScheduler("LineUp")
		Scheduler.Add(Script.RefName, "__takeOut", Project.Name, graphicOnAirItem, 0, owner = "LineUp")

def __takeOut(graphicOnAirItem):
	helper.GraphicTakeOut("ScoreWithScorers_OtherMatches", GraphicTemplatesManager, OutputManager, IntelliflowController)
	IntelliflowController.TakeOut(graphicOnAirItem.Graphic, OutputManager.ActiveChannelOutput)
	graphic = GraphicTemplatesManager.GetGraphicByName("LINEUP_STATS_ACTIVEMATCH")
	Task.Run(action = lambda : IntelliflowController.TakeIn(graphic, OutputManager.ActiveChannelOutput, IntelliflowController.EWorkflowType.Program))

def __beforeProgramOut(graphicOnAirItem, momentExecution):
	Scheduler.ClearScheduler("LineUp")

	#helper.GraphicTakeOut("ScoreWithScorers_OtherMatches", GraphicTemplatesManager, OutputManager, IntelliflowController)

def __afterPanic(graphicOnAirItem, momentExecution):
	Scheduler.ClearScheduler("LineUp")
	
def __clearTags(viewBag):
	for i in range(1,25):
		viewBag.SetString("tHomeName%02d" % i, "")
		viewBag.SetString("tHomeLastName%02d" % i, "")
		viewBag.SetString("tHomeNumber%02d" % i, "")
		viewBag.SetString("tHomeSubstitutionName%02d" % i, "")
		viewBag.SetString("tHomeSubstitutionLastName%02d" % i, "")
		viewBag.SetString("tHomeSubstitutionNumber%02d" % i, "")
		viewBag.SetString("tHomeStatName%02d" % i, "")
		viewBag.SetString("tHomeStatValue%02d" % i, "")
		viewBag.SetFloat("vAwayCard%02d" % i,0)
		viewBag.SetFloat("vHomeCard%02d" % i,0)
		
		
		viewBag.SetVisibility("vHomeAtRiskVisibility%02d" % i, False)
		viewBag.SetVisibility("vHomeSubstitutionAtRisk%02d" % i, False)
			
		viewBag.SetString("tAwayName%02d" % i, "")
		viewBag.SetString("tAwayLastName%02d" % i, "")
		viewBag.SetString("tAwayNumber%02d" % i, "")
		viewBag.SetString("tAwaySubstitutionName%02d" % i, "")
		viewBag.SetString("tAwaySubstitutionLastName%02d" % i, "")
		viewBag.SetString("tAwaySubstitutionNumber%02d" % i, "")
		viewBag.SetString("tAwayStatName%02d" % i, "")
		viewBag.SetString("tAwayStatValue%02d" % i, "")
		viewBag.SetVisibility("vAwayAtRiskVisibility%02d" % i, False)
		viewBag.SetVisibility("vAwaySubstitutionAtRisk%02d" % i, False)
		
	viewBag.SetFloat("vHomeSubstitutes", 0)
	viewBag.SetFloat("vAwaySubstitutes", 0)
	viewBag.SetVisibility("vHighlightVisibility", False)
	viewBag.SetTranslatedText("tHomeCoachFunction", "")
	viewBag.SetString("tHomeCoachFirstName", "")
	viewBag.SetString("tHomeCoachLastName", "")
	viewBag.SetVisibility("vHomeCoachAtRiskVisibility", False)
		
	viewBag.SetTranslatedText("tAwayCoachFunction", "")
	viewBag.SetString("tAwayCoachFirstName", "")
	viewBag.SetString("tAwayCoachLastName", "")
	viewBag.SetVisibility("vAwayCoachAtRiskVisibility", False)