Boy_Scouts_Scheduler.Algorithm.Score.deductStationRevisitedOnSameDayScore C# (CSharp) Метод

        public static int deductStationRevisitedOnSameDayScore(
            IEnumerable<Models.Activity> schedule, IEnumerable<Models.Group> groups,
            IEnumerable<Models.Station> stations, IEnumerable<Models.TimeSlot> timeSlots)
        {
            DateTime a = DateTime.Now;
            int revisitedPenalty = 0;

            //assignments for station categories on each day of camp
            //example: on day 3, Group "Knights1" has been assigned to
            //category "arts and crafts" twice and category "shooting" once
            IDictionary<int, Dictionary<Models.Group, Dictionary<string, int>>> dailyCategoryAssignments =
                new Dictionary<int, Dictionary<Models.Group, Dictionary<string, int>>>();

            //assignments for stations on each day of camp
            //example: on day 2, Group "Knights2" has been assigned to station
            IDictionary<int, Dictionary<Models.Group, Dictionary<Models.Station, int>>> dailyStationAssignments =
                new Dictionary<int, Dictionary<Models.Group, Dictionary<Models.Station, int>>>();

            foreach (Models.Activity activity in schedule)
            {
                Models.Group group = activity.Group;
                Models.Station station = activity.Station;
                string stationCategory = activity.Station.Category;

                if (stationCategory == null)
                    continue;

                int dayNum = activity.TimeSlot.Start.DayOfYear;

                //check if the same station category has already been assigned on the same day
                if (dailyCategoryAssignments.ContainsKey(dayNum))
                {
                    if (dailyCategoryAssignments[dayNum].ContainsKey(group))
                    {
                        if (dailyCategoryAssignments[dayNum][group].ContainsKey(stationCategory))
                        {
                            int numVisits = dailyCategoryAssignments[dayNum][group][stationCategory];
                            revisitedPenalty += numVisits;
                            dailyCategoryAssignments[dayNum][group][stationCategory]++;
                        }
                        else
                        {
                            dailyCategoryAssignments[dayNum][group].Add(stationCategory, 1);
                        }
                    }

                    else
                    {
                        Dictionary<string, int> stationAssignmentValue =
                           new Dictionary<string, int>();
                        stationAssignmentValue.Add(stationCategory, 1);
                        dailyCategoryAssignments[dayNum].Add(group, stationAssignmentValue);
                    }
                }

                else
                {
                    Dictionary<Models.Group, Dictionary<string, int>> groupAssignments =
                        new Dictionary<Models.Group, Dictionary<string, int>>();
                    Dictionary<string, int> stationAssignmentValue =
                        new Dictionary<string, int>();

                    stationAssignmentValue.Add(stationCategory, 1);
                    groupAssignments.Add(group, stationAssignmentValue);
                    dailyCategoryAssignments.Add(dayNum, groupAssignments);
                }

                //check if the current station has already been assigned on the same day
                if (dailyStationAssignments.ContainsKey(dayNum))
                {
                    if (dailyStationAssignments[dayNum].ContainsKey(group))
                    {
                        if (dailyStationAssignments[dayNum][group].ContainsKey(station))
                        {
                            int numVisits = dailyStationAssignments[dayNum][group][station];
                            revisitedPenalty += numVisits;
                            dailyStationAssignments[dayNum][group][station]++;
                        }
                        else
                        {
                            dailyStationAssignments[dayNum][group].Add(station, 1);
                        }
                    }

                    else
                    {
                        Dictionary<Models.Station, int> stationAssignmentValue =
                           new Dictionary<Models.Station, int>();
                        stationAssignmentValue.Add(station, 1);
                        dailyStationAssignments[dayNum].Add(group, stationAssignmentValue);
                    }
                }

                else
                {
                    Dictionary<Models.Group, Dictionary<Models.Station, int>> groupAssignments =
                        new Dictionary<Models.Group, Dictionary<Models.Station, int>>();
                    Dictionary<Models.Station, int> stationAssignmentValue =
                        new Dictionary<Models.Station, int>();

                    stationAssignmentValue.Add(station, 1);
                    groupAssignments.Add(group, stationAssignmentValue);
                    dailyStationAssignments.Add(dayNum, groupAssignments);
                }

            }

            DateTime b = DateTime.Now;
            TimeSpan c = b.Subtract(a);
            return (revisitedPenalty * -90);
        }