[longomatch] Include score and penalties in players stats

[Andoni Morales Alastruey <amorales src gnome org>]

commit 28c14413afdb37e22bd868f79632d2880292a378
Author: Andoni Morales Alastruey <ylatuya gmail com>
Date:   Thu Nov 20 15:06:04 2014 +0100

    Include score and penalties in players stats

 LongoMatch.Core/Stats/PlayerEventTypeStats.cs |   66 +++++++++++++++++++------
 LongoMatch.Core/Stats/PlayerStats.cs          |    9 +++-
 LongoMatch.Core/Stats/ProjectStats.cs         |    8 +--
 LongoMatch.Core/Store/Project.cs              |   24 ++++++++--
 4 files changed, 81 insertions(+), 26 deletions(-)
---
diff --git a/LongoMatch.Core/Stats/PlayerEventTypeStats.cs b/LongoMatch.Core/Stats/PlayerEventTypeStats.cs
index c213650..4dbedfd 100644
--- a/LongoMatch.Core/Stats/PlayerEventTypeStats.cs
+++ b/LongoMatch.Core/Stats/PlayerEventTypeStats.cs
@@ -20,6 +20,7 @@ using System.Linq;
 using LongoMatch.Core.Store;
 using LongoMatch.Core.Common;
 using System.Collections.Generic;
+using Mono.Unix;
 
 namespace LongoMatch.Core.Stats
 {
@@ -27,43 +28,77 @@ namespace LongoMatch.Core.Stats
        {
                EventsFilter filter;
                Player player;
+               Project project;
                List<TimelineEvent> events;
-               
-               public PlayerEventTypeStats (Project project, EventsFilter filter, Player player, 
AnalysisEventType evType)
+
+               public PlayerEventTypeStats (Project project, EventsFilter filter, Player player, EventType 
evType)
                {
                        this.filter = filter;
                        this.player = player;
+                       this.project = project;
                        this.EventType = evType;
                }
-               
+
                public int TotalCount {
                        get;
                        set;
                }
 
-               public AnalysisEventType EventType {
+               public EventType EventType {
                        get;
                        set;
                }
 
                public void Update ()
                {
-                       events = filter.VisiblePlays.Where (e => e.Players.Contains (player) && e.EventType 
== EventType).ToList();
-                       TotalCount = events.Count;
-                       SubcategoriesStats = new List<SubCategoryStat> ();
-                       var tagsByGroup = EventType.TagsByGroup;
-                       foreach (string grp in tagsByGroup.Keys) {
-                               SubCategoryStat substat = new SubCategoryStat (grp);
-                               foreach (Tag t in tagsByGroup[grp]) {
-                                       int count, localTeamCount, visitorTeamCount;
-                                       count = events.Count (e => e.Tags.Contains (t));
-                                       PercentualStat pStat = new PercentualStat (t.Value, count, 0, 0, 
events.Count);
+                       events = filter.VisiblePlays.Where (e => e.Players.Contains (player) && 
e.EventType.Equals (EventType)).ToList ();
+                       
+                       if (EventType is ScoreEventType) {
+                               TotalCount = events.Sum (e => (e as ScoreEvent).Score.Points);
+                               SubcategoriesStats = new List<SubCategoryStat> ();
+                               SubCategoryStat substat = new SubCategoryStat (Catalog.GetString ("Score"));
+                               foreach (Score score in project.Scores) {
+                                       int count;
+                                       var scores = events.Where (e => (e as ScoreEvent).Score == score);
+                                       if (score.Points == 0) {
+                                               count = scores.Count ();
+                                       } else {
+                                               count = scores.Sum (e => (e as ScoreEvent).Score.Points);
+                                       }
+                                       PercentualStat pStat = new PercentualStat (score.Name, count, 0, 0, 
TotalCount);
+                                       substat.OptionStats.Add (pStat);
+                               }
+                               SubcategoriesStats.Add (substat);
+                       } else if (EventType is PenaltyCardEventType) {
+                               TotalCount = events.Count;
+                               SubcategoriesStats = new List<SubCategoryStat> ();
+                               SubCategoryStat substat = new SubCategoryStat (Catalog.GetString 
("Penalties"));
+                               foreach (PenaltyCard penalty in project.PenaltyCards) {
+                                       var penalties = events.Where (e => (e as 
PenaltyCardEvent).PenaltyCard == penalty);
+                                       PercentualStat pStat = new PercentualStat (penalty.Name, 
penalties.Count (), 0, 0, TotalCount);
                                        substat.OptionStats.Add (pStat);
                                }
                                SubcategoriesStats.Add (substat);
+                       } else {
+                               AnalysisEventType evType = EventType as AnalysisEventType;
+                               TotalCount = events.Count;
+                               
+                               SubcategoriesStats = new List<SubCategoryStat> ();
+                               var tagsByGroup = evType.TagsByGroup;
+                               foreach (string grp in tagsByGroup.Keys) {
+                                       SubCategoryStat substat = new SubCategoryStat (grp);
+                                       foreach (Tag t in tagsByGroup[grp]) {
+                                               int count;
+                                               count = events.Count (e => e.Tags.Contains (t));
+                                               PercentualStat pStat = new PercentualStat (t.Value, count, 0, 
0, events.Count);
+                                               substat.OptionStats.Add (pStat);
+                                       }
+                                       SubcategoriesStats.Add (substat);
+                               }
                        }
+                       
                }
-               
+
                public List<SubCategoryStat> SubcategoriesStats {
                        get;
                        protected set;
@@ -80,7 +115,6 @@ namespace LongoMatch.Core.Stats
                                return events.Where (e => e.GoalPosition != null).Select (e => 
e.GoalPosition).ToList ();
                        }
                }
-
        }
 }
 
diff --git a/LongoMatch.Core/Stats/PlayerStats.cs b/LongoMatch.Core/Stats/PlayerStats.cs
index 5f70842..9e0cdb2 100644
--- a/LongoMatch.Core/Stats/PlayerStats.cs
+++ b/LongoMatch.Core/Stats/PlayerStats.cs
@@ -16,6 +16,7 @@
 //  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
 //
 using System;
+using System.Linq;
 using LongoMatch.Core.Common;
 using LongoMatch.Core.Store;
 using System.Collections.Generic;
@@ -33,9 +34,15 @@ namespace LongoMatch.Core.Stats
                        this.filter = filter;
                        this.Player = player;
                        PlayerEventStats = new List<PlayerEventTypeStats> ();
+                       foreach (EventType evtType in project.EventTypes.OfType<ScoreEventType> ()) {
+                               PlayerEventStats.Add (new PlayerEventTypeStats (project, filter, player, 
evtType));
+                       }
+                       foreach (EventType evtType in project.EventTypes.OfType<PenaltyCardEventType> ()) {
+                               PlayerEventStats.Add (new PlayerEventTypeStats (project, filter, player, 
evtType));
+                       }
                        foreach (EventType evtType in project.EventTypes) {
                                if (evtType is AnalysisEventType) {
-                                       PlayerEventStats.Add (new PlayerEventTypeStats (project, filter, 
player, evtType as AnalysisEventType));
+                                       PlayerEventStats.Add (new PlayerEventTypeStats (project, filter, 
player, evtType));
                                }
                        }
                }
diff --git a/LongoMatch.Core/Stats/ProjectStats.cs b/LongoMatch.Core/Stats/ProjectStats.cs
index ade9564..948b185 100644
--- a/LongoMatch.Core/Stats/ProjectStats.cs
+++ b/LongoMatch.Core/Stats/ProjectStats.cs
@@ -83,12 +83,10 @@ namespace LongoMatch.Core.Stats
                        EventTypeStats = new List <EventTypeStats> ();
                        
                        foreach (EventType evt in project.EventTypes) {
-                               if (evt is ScoreEventType || evt is SubstitutionEventType ||
-                                       evt is PenaltyCardEventType) {
-                                       continue;
+                               if (evt is AnalysisEventType) {
+                                       EventTypeStats evstats = new EventTypeStats (project, filter, evt);
+                                       EventTypeStats.Add (evstats);
                                }
-                               EventTypeStats evstats = new EventTypeStats (project, filter, evt);
-                               EventTypeStats.Add (evstats);
                        }
 
                        HomeTeamStats = new TeamStats (project, filter, Team.LOCAL);
diff --git a/LongoMatch.Core/Store/Project.cs b/LongoMatch.Core/Store/Project.cs
index 899197f..b93bc00 100644
--- a/LongoMatch.Core/Store/Project.cs
+++ b/LongoMatch.Core/Store/Project.cs
@@ -141,16 +141,32 @@ namespace LongoMatch.Core.Store
                }
                
                [JsonIgnore]
-               public List<TimelineEvent> ScorePlays {
+               public List<Score> Scores {
                        get {
-                               return Timeline.OfType<ScoreEvent>().Select (t => (TimelineEvent) t).ToList();
+                               var scores = Dashboard.List.OfType<ScoreButton> ().Select (b => b.Score);
+                               return ScorePlays.Select (e => e.Score).Union (scores).OrderByDescending 
(s=>s.Points).ToList();
                        }
                }
                
                [JsonIgnore]
-               public List<TimelineEvent> PenaltyCardsPlays {
+               public List<PenaltyCard> PenaltyCards {
                        get {
-                               return Timeline.OfType<PenaltyCardEvent>().Select (t => (TimelineEvent) 
t).ToList();
+                               var pc = Dashboard.List.OfType<PenaltyCardButton> ().Select (b => 
b.PenaltyCard);
+                               return PenaltyCardsPlays.Select (e => e.PenaltyCard).Union (pc).ToList();
+                       }
+               }
+
+               [JsonIgnore]
+               public List<ScoreEvent> ScorePlays {
+                       get {
+                               return Timeline.OfType<ScoreEvent>().Select (t => t).ToList();
+                       }
+               }
+               
+               [JsonIgnore]
+               public List<PenaltyCardEvent> PenaltyCardsPlays {
+                       get {
+                               return Timeline.OfType<PenaltyCardEvent>().Select (t => t).ToList();
                        }
                }