public async Task <IActionResult> ConfirmedBattleReports(ConfirmedBattleReportsViewModel viewModel)
        {
            if (viewModel.UserName != User.Identity.Name)
            {
                return(Unauthorized());
            }

            var filteredBattleReports = _db.BattleReports.Where(br => (br.PostersUsername == viewModel.UserName || br.OpponentsUsername == viewModel.UserName) && br.ConfirmedByOpponent);

            viewModel.TimePeriodOptions = StaticDetails.TimePeriodOptions;
            List <Faction> factions = await _db.Factions.OrderBy(f => f.Name).ToListAsync();

            List <Theme> themes = await _db.Themes.ToListAsync();

            List <Caster> casters = await _db.Casters.ToListAsync();

            viewModel.FactionOptions = new List <string>()
            {
                StaticDetails.AllFactions
            };
            foreach (Faction faction in factions)
            {
                viewModel.FactionOptions.Add(faction.Name);
            }
            viewModel.ThemeOptions = new List <string>()
            {
                StaticDetails.AllThemes
            };
            viewModel.CasterOptions = new List <string>()
            {
                StaticDetails.AllCasters
            };
            viewModel.EnemyThemeOptions = new List <string>()
            {
                StaticDetails.AllThemes
            };
            viewModel.EnemyCasterOptions = new List <string>()
            {
                StaticDetails.AllCasters
            };
            viewModel.GameSizeOptions     = StaticDetails.GameSizeFilterOptions;
            viewModel.EndConditionOptions = StaticDetails.EndconditionFilterOptions;
            viewModel.ScenarioOptions     = StaticDetails.ScenarioFilterOptions;
            viewModel.OutComeOptions      = StaticDetails.OutComeOptions;

            if (viewModel.TimePeriod == StaticDetails.LastYear)
            {
                filteredBattleReports = filteredBattleReports.Where(br => br.DatePlayed > DateTime.Today.AddYears(-1));
            }
            else if (viewModel.TimePeriod == StaticDetails.Last6Months)
            {
                filteredBattleReports = filteredBattleReports.Where(br => br.DatePlayed > DateTime.Today.AddMonths(-6));
            }
            else if (viewModel.TimePeriod == StaticDetails.LastMonth)
            {
                filteredBattleReports = filteredBattleReports.Where(br => br.DatePlayed > DateTime.Today.AddMonths(-1));
            }

            if (viewModel.Faction != StaticDetails.AllFactions)
            {
                Faction faction = factions.First(f => f.Name == viewModel.Faction);

                List <Theme> factionThemes = themes.Where(t => t.FactionId == faction.Id).OrderBy(t => t.Name).ToList();
                foreach (Theme theme in factionThemes)
                {
                    viewModel.ThemeOptions.Add(theme.Name);
                }

                List <Caster> factionCasters = casters.Where(c => c.FactionId == faction.Id).OrderBy(c => c.Name).ToList();
                foreach (Caster caster in factionCasters)
                {
                    viewModel.CasterOptions.Add(caster.Name);
                }

                filteredBattleReports = filteredBattleReports.Where(br => (br.PostersUsername == viewModel.UserName && br.PostersFaction == viewModel.Faction) || (br.OpponentsUsername == viewModel.UserName && br.OpponentsFaction == viewModel.Faction));
            }

            if (viewModel.Theme != StaticDetails.AllThemes)
            {
                filteredBattleReports = filteredBattleReports.Where(br => (br.PostersUsername == viewModel.UserName && br.PostersTheme == viewModel.Theme) || (br.OpponentsUsername == viewModel.UserName && br.OpponentsTheme == viewModel.Theme));
            }

            if (viewModel.Caster != StaticDetails.AllCasters)
            {
                filteredBattleReports = filteredBattleReports.Where(br => (br.PostersUsername == viewModel.UserName && br.PostersCaster == viewModel.Caster) || (br.OpponentsUsername == viewModel.UserName && br.OpponentsCaster == viewModel.Caster));
            }

            if (viewModel.EnemyFaction != StaticDetails.AllFactions)
            {
                Faction enemyFaction = factions.First(f => f.Name == viewModel.EnemyFaction);

                List <Theme> enemyThemes = themes.Where(t => t.FactionId == enemyFaction.Id).OrderBy(t => t.Name).ToList();
                foreach (Theme theme in enemyThemes)
                {
                    viewModel.EnemyThemeOptions.Add(theme.Name);
                }

                List <Caster> enemyCasters = casters.Where(c => c.FactionId == enemyFaction.Id).OrderBy(c => c.Name).ToList();
                foreach (Caster caster in enemyCasters)
                {
                    viewModel.EnemyCasterOptions.Add(caster.Name);
                }

                filteredBattleReports = filteredBattleReports.Where(br => (br.PostersUsername != viewModel.UserName && br.PostersFaction == viewModel.EnemyFaction) || (br.OpponentsUsername != viewModel.UserName && br.OpponentsFaction == viewModel.EnemyFaction));
            }

            if (viewModel.EnemyTheme != StaticDetails.AllThemes)
            {
                filteredBattleReports = filteredBattleReports.Where(br => (br.PostersUsername != viewModel.UserName && br.PostersTheme == viewModel.EnemyTheme) || (br.OpponentsUsername != viewModel.UserName && br.OpponentsTheme == viewModel.EnemyTheme));
            }

            if (viewModel.EnemyCaster != StaticDetails.AllCasters)
            {
                filteredBattleReports = filteredBattleReports.Where(br => (br.PostersUsername != viewModel.UserName && br.PostersCaster == viewModel.EnemyCaster) || (br.OpponentsUsername != viewModel.UserName && br.OpponentsCaster == viewModel.EnemyCaster));
            }

            if (viewModel.GameSize != StaticDetails.AllGameSizes)
            {
                filteredBattleReports = filteredBattleReports.Where(br => br.GameSize.ToString() == viewModel.GameSize);
            }

            if (viewModel.EndCondition != StaticDetails.AllEndConditions)
            {
                filteredBattleReports = filteredBattleReports.Where(br => br.EndCondition == viewModel.EndCondition);
            }

            if (viewModel.Scenario != StaticDetails.AllScenarios)
            {
                filteredBattleReports = filteredBattleReports.Where(br => br.Scenario == viewModel.Scenario);
            }

            if (viewModel.OutCome != StaticDetails.AllOutcomes)
            {
                if (viewModel.OutCome == StaticDetails.YouWon)
                {
                    filteredBattleReports = filteredBattleReports.Where(br => br.WinnersUsername == viewModel.UserName);
                }
                else if (viewModel.OutCome == StaticDetails.YouLost)
                {
                    filteredBattleReports = filteredBattleReports.Where(br => br.LosersUsername == viewModel.UserName);
                }
            }

            viewModel.BattleReports = await filteredBattleReports.OrderByDescending(br => br.DatePlayed).ToListAsync();

            return(View(viewModel));
        }
        public async Task <IActionResult> ConfirmedBattleReports(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                return(NotFound());
            }

            if (id != User.Identity.Name)
            {
                return(Unauthorized());
            }

            List <BattleReport> battleReports = await _db.BattleReports.Where(br => (br.PostersUsername == id || br.OpponentsUsername == id) && br.ConfirmedByOpponent).OrderByDescending(br => br.DatePlayed).ToListAsync();

            if (battleReports == null)
            {
                return(NotFound());
            }

            List <string> factionOptions = new List <string>()
            {
                StaticDetails.AllFactions
            };
            List <string> themeOptions = new List <string>()
            {
                StaticDetails.AllThemes
            };
            List <string> casterOptions = new List <string>()
            {
                StaticDetails.AllCasters
            };
            List <Faction> factions = await _db.Factions.OrderBy(f => f.Name).ToListAsync();

            foreach (Faction faction in factions)
            {
                factionOptions.Add(faction.Name);
            }

            ConfirmedBattleReportsViewModel viewModel = new ConfirmedBattleReportsViewModel()
            {
                BattleReports       = battleReports,
                UserName            = User.Identity.Name,
                TimePeriod          = StaticDetails.AllTime,
                TimePeriodOptions   = StaticDetails.TimePeriodOptions,
                Faction             = StaticDetails.AllFactions,
                FactionOptions      = factionOptions,
                Theme               = StaticDetails.AllThemes,
                ThemeOptions        = themeOptions,
                Caster              = StaticDetails.AllCasters,
                CasterOptions       = casterOptions,
                EnemyFaction        = StaticDetails.AllFactions,
                EnemyTheme          = StaticDetails.AllThemes,
                EnemyThemeOptions   = themeOptions,
                EnemyCaster         = StaticDetails.AllCasters,
                EnemyCasterOptions  = casterOptions,
                GameSizeOptions     = StaticDetails.GameSizeFilterOptions,
                GameSize            = StaticDetails.AllGameSizes,
                EndConditionOptions = StaticDetails.EndconditionFilterOptions,
                EndCondition        = StaticDetails.AllEndConditions,
                ScenarioOptions     = StaticDetails.ScenarioFilterOptions,
                Scenario            = StaticDetails.AllScenarios,
                OutComeOptions      = StaticDetails.OutComeOptions,
                OutCome             = StaticDetails.AllOutcomes,
                HideFilters         = true
            };

            return(View(viewModel));
        }