import Fluent
import Vapor



struct CODDate {
    let month:Int
    let year:Int
    let day: Int
    let hour:Int
    let minute:Int
}


struct StatsController: RouteCollection {
    func boot(routes: RoutesBuilder) throws {
        let statsRoute = routes.grouped("cod-tracker","api", "stats")
        statsRoute.get("allMatches", use: index)
        statsRoute.get("totalWins", use: totalWins)
        statsRoute.get("totalLosses", use: totalLosses)
        statsRoute.get("overall", use: overall)
        statsRoute.get("allDaily", use: allDaily)
        statsRoute.post("logMatch", use: logMatch)
        statsRoute.get("history","page",":page", use: history)
        statsRoute.get("history", use: history)
        statsRoute.get("maps", use: mapRecords)
        statsRoute.get("maps","game",":game","competitive",":competitive",use: mapRecords)
        statsRoute.get("maps","game",":game","competitive",":competitive", "gamemode", ":gamemode",use: mapRecords)
        statsRoute.get("dashboard", use: dashboard)
        statsRoute.get("recalculate", use: recalc)
        statsRoute.get("stats","q",":query", use: history)
    }
    
    
    func dashboard(db: Database) throws -> EventLoopFuture<DashboardStats> {
        let statistics = WinLossRecords.query(on: db).all()
        let adamAffectedMatches = Match.query(on: db).filter(\.$finalKillRuinedPlayerId == 6).count()
      //  let totalMWGames = Match.query(on: db).filter(\.$codGame == "mw").count()
        
        
        let colourSchemeConfigs =  ColourScheme.query(on: db).all().map { colourScheme in
            return colourScheme.map { cs in
                return cs.colorSchemeConfig
            }
        }
        
        return (statistics.and(adamAffectedMatches).and(colourSchemeConfigs)).map { arg -> (DashboardStats) in
            
            let (((statistics, adamAffectedMatches),colors)) = arg
            
            
            //  return statistics.map { statistics in
            return DashboardStats(dashboardItems: (statistics.map({ statisticItem in
                
                
                let title = statisticItem.title
                var title2:String? = ""
                var content1 = ""
                var content2 = ""
                var sortOrder = 0
                var backgroundColor = "484848"
                
                if statisticItem.codTrackerId == "no_hyder_overall"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 100
                }
                
                else if statisticItem.codTrackerId == "mw_overall"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 20
                    backgroundColor = colors.first(where: {$0.gameId == "mw"})?.tileColour ?? backgroundColor
                }
                
                else if statisticItem.codTrackerId == "mw_six_players"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 60
                    backgroundColor = colors.first(where: {$0.gameId == "mw"})?.tileColour ?? backgroundColor
                    
                }
                else if statisticItem.codTrackerId == "2021_overall"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 50
                    
                }
                else if statisticItem.codTrackerId == "bocw_overall"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 30
                    backgroundColor = colors.first(where: {$0.gameId == "bocw"})?.tileColour ?? backgroundColor
                    
                }
                else if statisticItem.codTrackerId == "with_hyder_overall"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 110
                }
                else if statisticItem.codTrackerId == "mw_five_players"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 70
                    backgroundColor = colors.first(where: {$0.gameId == "mw"})?.tileColour ?? backgroundColor
                    
                }
                else if statisticItem.codTrackerId == "casual_overall"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 40
                    
                    
                }
                else if statisticItem.codTrackerId == "overall_four_players"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 80
                }
                else if statisticItem.codTrackerId == "overall"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 10
                }
                else if statisticItem.codTrackerId == "2020_overall"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 90
                    
                }
                
                else if statisticItem.codTrackerId == "bocw_nuketown_halloween"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = 41
                    backgroundColor = colors.first(where: {$0.gameId == "bocw"})?.tileColour ?? backgroundColor

                }
                
                else if statisticItem.codTrackerId == "vg_casual"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = -80
                    backgroundColor = colors.first(where: {$0.gameId == "vg"})?.tileColour ?? backgroundColor
                    
                }
                
                else if statisticItem.codTrackerId == "bocw_casual"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = -79
                    backgroundColor = colors.first(where: {$0.gameId == "bocw"})?.tileColour ?? backgroundColor
                }
                else if statisticItem.codTrackerId == "vg_competitive"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = -81
                    backgroundColor = colors.first(where: {$0.gameId == "vg"})?.tileColour ?? backgroundColor
                }
                
                else if statisticItem.codTrackerId == "mw2_casual"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = -82
                    backgroundColor = colors.first(where: {$0.gameId == "mw2"})?.tileColour ?? backgroundColor
                }
                
                else if statisticItem.codTrackerId == "mw2_competitive"{
                    title2 = "Ratio"
                    content1 = "\(statisticItem.wins)-\(statisticItem.losses)"
                    content2 = Utils.getRatio(wins: statisticItem.wins, losses: statisticItem.losses)
                    sortOrder = -83
                    backgroundColor = colors.first(where: {$0.gameId == "mw2"})?.tileColour ?? backgroundColor
                }
                
                
                else {
                    
                }
                
                return DashboardItem(codTrackerId:statisticItem.codTrackerId, title: title, content: content1, title2: title2, content2: content2, sortOrder: sortOrder, backgroundColor:backgroundColor)
            } ) +
                                                   [
                                                    DashboardItem(codTrackerId: "adam_ruined_final_kills", title: "Final Kills Ruined by Adam", content: "\(adamAffectedMatches + 7)", title2: "", content2: "",sortOrder: 1000, backgroundColor: "484848"),
                                                  
                                                   ]
                                                  ).sorted{$0.sortOrder < $1.sortOrder}
            )
        }
    }
    
    func dashboard(req: Request) throws -> EventLoopFuture<DashboardStats> {
        
        return try dashboard(db: req.db)
    }
    
    func history(req: Request) throws -> EventLoopFuture<MatchHistory> {
        
        if let page = req.parameters.get("page", as: Int.self)  {
            
            return  Match.query(on: req.db).count().flatMap { (totalMatches) -> EventLoopFuture<MatchHistory> in
                
                let startRecord =  min (page * 20, totalMatches)
                let lastRecord = min (startRecord + 20, totalMatches)
                
                
                return Match.query(on: req.db).sort(\.$date, .descending).range(startRecord..<lastRecord).all().map { (matches) -> (MatchHistory) in
                    return MatchHistory(total:totalMatches, matches: matches, hasMorePages: lastRecord < totalMatches)
                }
                
            }
        }
        else {
            
            return  Match.query(on: req.db).count().flatMap { (totalMatches) -> EventLoopFuture<MatchHistory> in
                return Match.query(on: req.db).sort(\.$date, .descending).limit(20).all().map { (matches) -> (MatchHistory) in
                    return MatchHistory(total:totalMatches, matches: matches, hasMorePages: totalMatches > 20)
                }
            }
        }
    }
    
    
    func logMatch(req: Request) throws -> EventLoopFuture<Match> {
        
        
        let newMatch = try req.content.decode(Match.self)
        return newMatch.save(on: req.db).map {  newMatch}
    }
    
    func getCountedMatches(matches:[Match]) -> Stats{
        
        let countedMatches = matches.filter {
            return self.shouldCountMatch(match: $0)
        }
        
        let totals = countedMatches.reduce([0,0]) { (totals, match) -> [Int] in
            if match.win == true {
                return [totals[0] + 1, totals[1]]
                
            }
            else {
                return [totals[0], totals[1] + 1]
            }
        }
        
        let winCount = totals[0]
        let lossCount = totals[1]
        
        return Stats( totalWins: Int(winCount), totalLosses: Int(lossCount))
    }
    
    func getAllMatches(matches:[Match]) -> Stats{
        
        let totals = matches.reduce([0,0]) { (totals, match) -> [Int] in
            if match.win == true {
                return [totals[0] + 1, totals[1]]
                
            }
            else {
                return [totals[0], totals[1] + 1]
            }
        }
        
        let winCount = totals[0]
        let lossCount = totals[1]
        
        return Stats( totalWins: Int(winCount), totalLosses: Int(lossCount))
    }
    
    func getStatsWithMostRecentDailyRecord(sortedMatches:[Match], game:String? = nil) -> StatsWithMostRecentDailyRecord {
        
        let stats = getCountedMatches(matches: sortedMatches)
        //print ("MRR STATS  \(Date().timeIntervalSince(startTime))")
        
        let mostRecentDailyStats = self.mostRecentDailyStats(matches: sortedMatches, game: game)
        //print ("MRR DAILY  \(Date().timeIntervalSince(startTime))")
        
        let ret = StatsWithMostRecentDailyRecord(winLoss: stats.winLossRatio, totalWins: stats.totalWins, totalLosses: stats.totalLosses, mostRecentRecord:"\(mostRecentDailyStats.totalWins)-\(mostRecentDailyStats.totalLosses)")
        
        return ret
    }
    
    
    
    
    func mostRecentDailyStats (matches:[Match], game:String? = nil) -> Stats{
        
        let daysPlayed = getDaysPlayed(sortedMatches: matches)
        let lastDayPlayed = daysPlayed.last
        
        
        //print ("MDD days played  \(Date().timeIntervalSince(startTime))")
        
        return getCountedMatches(matches: matches.filter({ (match) -> Bool in
            var shouldInclude =
            match.date.day == lastDayPlayed?.day &&
            match.date.month == lastDayPlayed?.month &&
            match.date.year == lastDayPlayed?.year &&
            self.shouldCountMatch(match: match)
            
            if let game = game {
                shouldInclude = shouldInclude && match.codGame == game
            }
            return shouldInclude
        }))
    }
    
    
    
    private func shouldCountMatch (match:Match) -> Bool {
        
        let isColdWar = match.codGame == "bocw"
        let numberOfPlayers = self.numberOfPlayers(match: match)
        
        if match.competitive == false {
            return false
        }
        
        if isColdWar {
            if numberOfPlayers == 0 {
                return true
            }
            else if numberOfPlayers > 4 {
                return true
            }
            else {
                return false
            }
        }
        else {
            
            if numberOfPlayers > 4  || numberOfPlayers == 0 {
                return true
            }
            else if numberOfPlayers == 4 {
                return match.date < Date(timeIntervalSince1970: 1612159200)
                
            } // February 1 2021
            else {
                return false
            }
            
        }
    }
    
    
    func getStatsForYear(year:Int, db: Database) -> EventLoopFuture<Stats>{
        
        // Specify date components
        var dateComponents = DateComponents()
        dateComponents.year = year
        dateComponents.month = 1
        dateComponents.day = 1
        dateComponents.timeZone = TimeZone(abbreviation: "EST") // Japan Standard Time
        dateComponents.hour = 8
        dateComponents.minute = 0
        
        // Create date from components
        let userCalendar = Calendar(identifier: .gregorian) // since the components above (like year 1980) are for Gregorian
        let startDate = userCalendar.date(from: dateComponents)
        
        
        
        var endDateComponenents = DateComponents()
        endDateComponenents.year  = year + 1
        endDateComponenents.month = 1
        endDateComponenents.day = 1
        endDateComponenents.timeZone = TimeZone(abbreviation: "EST") // Japan Standard Time
        endDateComponenents.hour = 8
        endDateComponenents.minute = 0
        
        
        let endDate = userCalendar.date(from: endDateComponenents)
        
        
        return Match.query(on: db).filter(\.$date > startDate!).filter(\.$date < endDate!).all().map { (matches) -> (Stats) in
            return self.getCountedMatches(matches: matches)
        }
    }
    
    
    private func numberOfPlayers(match:Match) -> Int {
        return match.players?.components(separatedBy: ",").count ?? 0
    }
    
    private func getDaysPlayed(sortedMatches:[Match]) -> [CODDate] {
        
        
        let dates =  sortedMatches.suffix(30).map { (match) -> CODDate in
            return CODDate(month: match.date.month, year: match.date.year, day: match.date.day, hour: match.date.hour, minute: match.date.minute)
        }
        return dates.reduce([CODDate]()) { (datesPlayed, codDate) -> [CODDate] in
            
            if datesPlayed.contains(where: { (existingDate) -> Bool in
                if codDate.month == existingDate.month && codDate.year == existingDate.year && existingDate.day == codDate.day{
                    return true
                }
                return false
            }){
                return datesPlayed
            }else {
                
                return  datesPlayed + [codDate]
            }
        }
    }
    
    func getCumulativeWinLossRatios(matches:[Match]) -> [DataPoint] {
        
        let daysPlayed = getDaysPlayed(sortedMatches: matches)
        
        var cumulativeRatios : [DataPoint] = []
        var cumulativeWins:Int = 0
        var cumulativeLosses:Int = 0
        
        var dayMatches:[[Match]] = []
        
        var currentDay = daysPlayed.first?.day ?? 0
        var currentMonth = daysPlayed.first?.month  ?? 0
        var currentYear = daysPlayed.first?.year ?? 0
        
        let sortedMatches = matches.sorted { (m1, m2) -> Bool in
            return m1.date < m2.date
        }
        
        var currentMatches:[Match] = []
        
        for match in sortedMatches {
            if match.date.year == currentYear && match.date.month == currentMonth && match.date.day == currentDay {
                currentMatches.append(match)
            }
            else {
                dayMatches.append(currentMatches)
                currentMatches = [match]
                currentDay = match.date.day
                currentYear = match.date.year
                currentMonth = match.date.month
            }
        }
        
        for (i, matchGroup) in dayMatches.enumerated() {
            
            
            let stats = self.getCountedMatches(matches: matchGroup)
            
            cumulativeWins = cumulativeWins + stats.totalWins;
            cumulativeLosses = cumulativeLosses + stats.totalLosses;
            cumulativeRatios.append( DataPoint(x: Double(i), y: (Double(cumulativeWins) / (Double(cumulativeLosses) )), label: ("\(Utilities.monthToString(month: matchGroup.first!.date.month)) \( matchGroup.first!.date.day)")))
            
        }
        
        return cumulativeRatios
    }
    
    func index(req: Request) throws -> EventLoopFuture<[Match]> {
        return Match.query(on: req.db).sort(\.$date).all()
    }
    
    
    
    func totalWins(req: Request) throws -> EventLoopFuture<Int> {
        return Match.query(on: req.db)
            .filter(\.$win == true)
            .count()
    }
    
    func totalLosses(req: Request) throws -> EventLoopFuture<Int> {
        return Match.query(on: req.db)
            .filter(\.$win == false)
            .count()
    }
    
    func getMarchStats(req:Request) throws -> EventLoopFuture<Stats> {
        return getstatsForMonth(year: 2020, month: 03, req: req)
    }
    
    
    
    func getstatsForMonth(year:Int, month:Int, req: Request) -> EventLoopFuture<Stats>{
        
        let winCount = Match.query(on: req.db)
            .filter(\.$date >= getStartOfMonth(month: month, year: year))
            .filter(\.$date <= getEndOfMonth(month: month, year: year))
            .filter(\.$win == true )
            .count()
        
        
        let lossCount = Match.query(on: req.db)
            .filter(\.$date >= getStartOfMonth(month: month, year: year))
            .filter(\.$date <= getEndOfMonth(month: month, year: year))
            .filter(\.$win == false )
            .count()
        
        let combined = winCount.and(lossCount)
        
        return combined.map { (winCount, lossCount) -> (Stats) in
            return  Stats.init( totalWins: winCount, totalLosses: lossCount)
        }
    }
    
    
    func getCasualStats( db: Database) -> EventLoopFuture<Stats>{
        
        return  Match.query(on: db).filter(\.$competitive == false).all().map { matches in
            return Stats(totalWins: matches.filter{$0.win == true}.count, totalLosses: matches.filter{$0.win == false}.count)
        }
    }
    
    
    func getCasualStatsForGame( db: Database, gameId:String, afterDate:Date = Date(timeIntervalSince1970: 0)) -> EventLoopFuture<Stats>{
        return  Match.query(on: db).filter(\.$competitive == false).filter(\.$codGame == gameId).filter(\.$date > afterDate ).all().map { matches in
            return Stats(totalWins: matches.filter{$0.win == true}.count, totalLosses: matches.filter{$0.win == false}.count)
        }
    }

    
    
    
    func getStatsForDay(year:Int, month:Int, day:Int, req: Request) -> EventLoopFuture<Stats>{
        
        let winCount = Match.query(on: req.db)
            .filter(\.$date >= getStartOfDay(day:day, month: month, year: year))
            .filter(\.$date <= getEndOfDay(day: day, month: month, year: year))
            .filter(\.$win == true )
            .count()
        
        
        let lossCount = Match.query(on: req.db)
            .filter(\.$date >= getStartOfDay(day:day, month: month, year: year))
            .filter(\.$date <= getEndOfDay(day: day, month: month, year: year))
            .filter(\.$win == false )
            .count()
        
        let combined = winCount.and(lossCount)
        
        return combined.map { (winCount, lossCount) -> (Stats) in
            
            return  Stats.init(totalWins: winCount, totalLosses: lossCount)
        }
    }
    
    
    func statsForRecent(numberGames:Int, req:Request) -> EventLoopFuture<Stats> {
        
        let winCount = Match.query(on: req.db)
            .sort(\.$date)
            .range(lower: 0, upper: numberGames)
            .filter(\.$win == true )
            .count()
        
        
        let lossCount = Match.query(on: req.db)
            .sort(\.$date)
            .range(lower: 0, upper: numberGames)
            .filter(\.$win == false )
            .count()
        
        let combined = winCount.and(lossCount)
        
        return combined.map { (winCount, lossCount) -> (Stats) in
            return  Stats.init(totalWins: winCount, totalLosses: lossCount)
        }
    }
    
    
    
    
    private func getStartOfMonth(month:Int, year:Int) -> Date {
        let calendar = Calendar.current
        var components = DateComponents()
        components.timeZone = TimeZone(identifier: "GMT")
        components.day = 1
        components.month = month
        components.year = year
        components.hour = 0
        components.minute = 0
        return calendar.date(from: components)!
    }
    
    private func getEndOfMonth(month:Int, year:Int) -> Date {
        let calendar = Calendar.current
        var components = DateComponents()
        components.day = -0
        components.timeZone = TimeZone(identifier: "GMT")
        components.month = month + 1
        components.year = year
        components.hour = 23
        components.minute = 59
        return calendar.date(from: components)!
    }
    
    
    private func getStartOfDay(day:Int, month:Int, year:Int) -> Date {
        let calendar = Calendar.current
        var components = DateComponents()
        components.timeZone = TimeZone(identifier: "GMT")
        
        components.day = day
        components.month = month
        components.year = year
        components.hour = 0
        components.minute = 0
        return calendar.date(from: components)!
    }
    
    private func getEndOfDay(day:Int, month:Int, year:Int) -> Date {
        let calendar = Calendar.current
        var components = DateComponents()
        components.timeZone = TimeZone(identifier: "GMT")
        components.day = day
        components.month = month
        components.year = year
        components.hour = 23
        components.minute = 59
        return calendar.date(from: components)!
    }
    
    private func getStartDate() -> Date {
        
        let calendar = Calendar.current
        var components = DateComponents()
        components.timeZone = TimeZone(identifier: "GMT")
        components.day = 10
        components.month = 03
        components.year = 2020
        components.hour = 4
        components.minute = 0
        return  calendar.date(from: components)!
    }
    
    private func createDate(day:Int, month:Int, year:Int, hour:Int, minute:Int) -> Date {
        let calendar = Calendar.current
        
        var components = DateComponents()
        components.timeZone = TimeZone(identifier: "GMT")
        components.day = day
        components.month = month
        components.year = year
        components.hour = hour
        components.minute = minute
        return  calendar.date(from: components)!
    }
    
    func mostRecentDailyStats (req:Request) -> EventLoopFuture<Stats>{
        return getDaysPlayed(req: req).flatMap { (days) -> (EventLoopFuture<Stats>) in
            return self.getStatsForDay(year: days.first?.year ?? 0, month: days.first?.month ?? 0, day: days.first?.day ?? 0, req: req)
        }
    }
    
    func recalc(req:Request) -> EventLoopFuture<[String:Stats]> {
        return forceCalculatedStats(db: req.db)
    }
    
    func forceCalculatedStats(db: Database)   -> EventLoopFuture<[String:Stats]> {
        
        let statsWithHyder = statsWithPlayer(db: db, playerId: 5)
        let statsWithoutHyder = statsWithoutPlayer(db: db, playerId: 5)
        let statsFor2020 = getStatsForYear(year: 2020, db: db)
        let statsFor2021 = getStatsForYear(year: 2021, db: db)
        
        
        let hyderFuture = statsWithHyder.and(statsWithoutHyder)
        
        let hyderStats = hyderFuture.map { (withHyder, withoutHyder) -> [Stats] in
            return [withHyder, withoutHyder]
        }
        
        
        let casualOverall = getCasualStats(db: db)
        let bocwCasual = getCasualStatsForGame(db: db, gameId: "bocw")
        let mw2Casual =  getCasualStatsForGame(db: db, gameId: "mw2", afterDate: Date(timeIntervalSince1970: 1635823473))
        let vgCasual = getCasualStatsForGame(db: db, gameId: "vg", afterDate: Date(timeIntervalSince1970: 1635823473)) //nov 21 to exlude beta time in sept

        
        let matches = Match.query(on: db).sort( \.$date).all()
        
        return matches.and(hyderStats).and(statsFor2020).and(statsFor2021).and(casualOverall).and(bocwCasual).and(vgCasual).and(mw2Casual).map { arg -> ([String:Stats]) in
            
            let (((((((matches, hyderStats), statsFor2020), statsFor2021), casualOverall), bocwCasual), vgCasual),mw2Casual) = arg
            
            //print ("got matches  \(Date().timeIntervalSince(startTime))")
            
            let queue = DispatchQueue(label: "com.sledsoft.cod-tracker.queue", attributes: .concurrent)
            let group = DispatchGroup()
            
            var overallStats:StatsWithMostRecentDailyRecord?
            var mwStats:StatsWithMostRecentDailyRecord?
            
            var bocwStats:StatsWithMostRecentDailyRecord?
            var mostRecentStats:Stats?
            var mwSixPlayers:Stats?
            var mwFivePlayers:Stats?
            var overallFourPlayers:Stats?
            var blackOpsColdWarNuketownHalloween:Stats?
            var vgCompetitive:StatsWithMostRecentDailyRecord?
            var mw2Cometitive:StatsWithMostRecentDailyRecord?



            //            var mapStats:[Int:Stats]?
            //            var worstMap:Int?
            //            var bestMap:Int?
            //
            group.enter()
            queue.async {
                overallStats = self.getStatsWithMostRecentDailyRecord(sortedMatches: matches)
                group.leave()
            }
            
            group.enter()
            queue.async {
                mwStats = self.getStatsWithMostRecentDailyRecord(sortedMatches: matches.filter({ (match) -> Bool in
                    return match.codGame == "mw" && self.shouldCountMatch(match: match )
                }))
                group.leave()
                
            }
            
            
            group.enter()
            queue.async {
                
                bocwStats =  self.getStatsWithMostRecentDailyRecord(sortedMatches: matches.filter({ (match) -> Bool in
                    return match.codGame == "bocw"  && self.shouldCountMatch(match: match )
                }))
                
                
                group.leave()
            }
            
            group.enter()
            queue.async {
                overallFourPlayers = self.getAllMatchesByPlayerCount(matches: matches, playerCount: 4) //Feb
                group.leave()
            }
            
            
            group.enter()
            queue.async {
                mwFivePlayers = self.getCountedMatchesByPlayerCount(matches: matches.filter{$0.codGame == "mw"}, playerCount: 5)
                group.leave()
            }
            
            
            group.enter()
            queue.async {
                mwSixPlayers = self.getCountedMatchesByPlayerCount(matches: matches.filter{$0.codGame == "mw"}, playerCount: 6)
                group.leave()
            }
            
            group.enter()
            queue.async {
                blackOpsColdWarNuketownHalloween = self.getRecordForMapId(matches: matches.filter{$0.codGame == "bocw"}, mapId: "69")
                group.leave()
            }
            
            
            group.enter()
            queue.async {
                
                vgCompetitive =  self.getStatsWithMostRecentDailyRecord(sortedMatches: matches.filter({ (match) -> Bool in
                    return match.codGame == "vg"  && self.shouldCountMatch(match: match )
                }))
                
                
                group.leave()
            }
            
            group.enter()
            queue.async {
                
                mw2Cometitive =  self.getStatsWithMostRecentDailyRecord(sortedMatches: matches.filter({ (match) -> Bool in
                    return match.codGame == "mw2"  && self.shouldCountMatch(match: match )
                }))
                
                
                group.leave()
            }
            
            group.wait()
            
            return [
                "bocw_nuketown_halloween":Stats(totalWins: blackOpsColdWarNuketownHalloween!.totalWins, totalLosses: blackOpsColdWarNuketownHalloween!.totalLosses),
                "mw_overall":Stats(totalWins: mwStats!.totalWins, totalLosses: mwStats!.totalLosses),
                "no_hyder_overall":Stats(totalWins: hyderStats[1].totalWins, totalLosses: hyderStats[1].totalLosses),
                "with_hyder_overall":Stats(totalWins:hyderStats[0].totalWins, totalLosses: hyderStats[0].totalLosses),
                "bocw_overall":Stats(totalWins: bocwStats!.totalWins, totalLosses:  bocwStats!.totalLosses),
                "2020_overall":Stats(totalWins: statsFor2020.totalWins, totalLosses: statsFor2020.totalLosses),
                "2021_overall":Stats(totalWins: statsFor2021.totalWins, totalLosses: statsFor2021.totalLosses),
                "mw_six_players":Stats(totalWins: mwSixPlayers!.totalWins, totalLosses: mwSixPlayers!.totalLosses),
                "overall_four_players":Stats(totalWins: overallFourPlayers!.totalWins, totalLosses: overallFourPlayers!.totalLosses),
                "mw_five_players":Stats(totalWins: mwFivePlayers!.totalWins, totalLosses: mwFivePlayers!.totalLosses),
                "overall":Stats(totalWins: overallStats!.totalWins, totalLosses: overallStats!.totalLosses),
                "casual_overall":Stats(totalWins: casualOverall.totalWins, totalLosses: casualOverall.totalLosses),
                "bocw_casual":Stats(totalWins: bocwCasual.totalWins, totalLosses: bocwCasual.totalLosses),
                "vg_casual":Stats(totalWins: vgCasual.totalWins, totalLosses: vgCasual.totalLosses),
                "vg_competitive":Stats(totalWins: vgCompetitive!.totalWins, totalLosses: vgCompetitive!.totalLosses),
                "mw2_casual":Stats(totalWins: mw2Casual.totalWins, totalLosses: mw2Casual.totalLosses),
                "mw2_competitive":Stats(totalWins: mw2Cometitive!.totalWins, totalLosses: mw2Cometitive!.totalLosses),

            ]
        }
        
    }
    
    
    func overall(db: Database) throws  -> EventLoopFuture<OverallStats> {
        
        
        let dashboardStats = try dashboard(db:db)
        
        let matches = Match.query(on: db).sort( \.$date).all()
        
        let mapConfigs = getMapConfigs(db: db)
        
        
        return matches.and(dashboardStats).and(mapConfigs).map { arg -> (OverallStats) in
            
            let ((matches, dashboardStats),mapConfigs) = arg
            
            
            let queue = DispatchQueue(label: "com.sledsoft.cod-tracker.queue", attributes: .concurrent)
            let group = DispatchGroup()
            
            var mapStats:[Int:Stats]?
            var worstMap:Int?
            var bestMap:Int?
            
            //
            group.enter()
            queue.async {
                mapStats = self.getMapStats(matches: matches,game: "mw", competitive: true)
                //print ("maps done \(Date().timeIntervalSince(startTime))")
                group.leave()
                
            }
            //
            group.enter()
            queue.async {
                let mapStats = self.getMapStats(matches: matches,game: "mw", competitive: true)
                
                bestMap = self.getBestMap(records: mapStats)
                group.leave()
            }
            
            group.enter()
            queue.async {
                let mapStats = self.getMapStats(matches: matches,game: "mw", competitive: true)
                
                worstMap = self.getWorstMap(records: mapStats)
                group.leave()
            }
            
            group.wait()
            
            let dashboardItems:[DashboardItem] =
            
            (dashboardStats.dashboardItems +
             [
                DashboardItem(codTrackerId:"best_map_overall", title: "Best Map", content: mapConfigs.first{$0.mapId == bestMap}?.name ?? "error", title2: "Ratio", content2: "\(mapStats![bestMap!]!.winLossRatio)  \(mapStats![bestMap!]!.record)", sortOrder: 12),
                DashboardItem(codTrackerId:"worst_map_overall", title: "Worst Map", content: mapConfigs.first{$0.mapId == worstMap}?.name ?? "error", title2: "Ratio", content2: "\(mapStats![worstMap!]!.winLossRatio)  \(mapStats![worstMap!]!.record)",sortOrder: 13),
                
             ]).sorted{
                 $0.sortOrder < $1.sortOrder
             }
            return OverallStats(dashboardItems: dashboardItems)
        }
    }
    
    
    func overall(req: Request) throws -> EventLoopFuture<OverallStats> {
        
        return try overall(db: req.db)
        
        
    }
    
    func getMapConfigs(db: Database) -> EventLoopFuture<[MapConfig]> {
        
        return  Map.query(on: db).all().map { map in
            return map.map { m in
                return m.mapConfig
            }
        }
    }
    
    
    
    func mapRecords(req: Request) throws -> EventLoopFuture<[MapRecord]> {
        
        
        let matches = Match.query(on: req.db).all()
        let mapConfigs = getMapConfigs(db: req.db)
        
        return matches.and(mapConfigs).map { matches, mapConfigs in
            
            let mapStats:[Int:Stats]
            
            if let game = req.parameters.get("game", as: String.self),
               let competitive = req.parameters.get("competitive", as:Bool.self) {
                
                let gameMode =  req.parameters.get("gamemode", as:Int.self) ?? -2
                mapStats = self.getMapStats(matches: matches,game: game, competitive: competitive, gameMode: gameMode)
                
            }
            else {
                mapStats =  self.getMapStats(matches: matches,game: "mw", competitive: true)
            }
            
            
            let sortedMaps =  self.mapsSortedByBest(records: mapStats)
            
            let records =  sortedMaps.map { (mapId) -> MapRecord in
                return MapRecord(map: mapConfigs.first{$0.mapId == mapId}!, stats:  mapStats[mapId]!, ratio:mapStats[mapId]!.winLossRatio)
            }
            
            var wins:Double = 0
            var loss:Double = 0
            
            for record in records {
                //print("\(record.map.name) \(record.stats.record) \(record.ratio)")
                wins = wins + Double(record.stats.totalWins)
                loss = loss + Double(record.stats.totalLosses)
                
            }
            return records
            
        }
        
        
        
        
        //
        //        return Match.query(on: req.db).all().map { (matches) -> [MapRecord] in
        //
        //
        //
        //            let mapStats:[Int:Stats]
        //
        //            if let game = req.parameters.get("game", as: String.self),
        //               let competitive = req.parameters.get("competitive", as:Bool.self) {
        //
        //                 let gameMode =  req.parameters.get("gamemode", as:Int.self) ?? -2
        //                 mapStats = self.getMapStats(matches: matches,game: game, competitive: competitive, gameMode: gameMode)
        //
        //            }
        //            else {
        //               mapStats =  self.getMapStats(matches: matches,game: "mw", competitive: true)
        //            }
        //
        //
        //            let sortedMaps =  self.mapsSortedByBest(records: mapStats)
        //
        //            let records =  sortedMaps.map { (mapId) -> MapRecord in
        //                return MapRecord(map: MapData.allMaps[mapId]!, stats:  mapStats[mapId]!, ratio:mapStats[mapId]!.winLossRatio)
        //            }
        //
        //            var wins:Double = 0
        //            var loss:Double = 0
        //
        //            for record in records {
        //                //print("\(record.map.name) \(record.stats.record) \(record.ratio)")
        //                wins = wins + Double(record.stats.totalWins)
        //                loss = loss + Double(record.stats.totalLosses)
        //
        //            }
        //             return records
        //        }
    }
    
    func mapsSortedByBest (records :[ Int:Stats] )  -> [ Int ] {
        return records.keys.sorted { (map1, map2) -> Bool in
            return records[map1]?.getRatioDouble() ?? 0.0 < records[map2]?.getRatioDouble() ?? 0.0
        }.reversed()
    }
    
    func getCountedMatchesByPlayerCount(matches:[Match], playerCount:Int) -> Stats {
        return getCountedMatches(matches: matches.filter{$0.playerList.count == playerCount})
    }
    
    func getRecordForMapId(matches:[Match], mapId:String) -> Stats {
        return getAllMatches(matches: matches.filter{$0.map == mapId})
    }
    
    
    func getAllMatchesByPlayerCount(matches:[Match], playerCount:Int) -> Stats {
        return getAllMatches(matches: matches.filter{$0.playerList.count == playerCount})
    }
    
    func getBestMap (records :[ Int:Stats] )  -> Int {
        
        let maps = records.keys.sorted { (map1, map2) -> Bool in
            return records[map1]?.getRatioDouble() ?? 0.0 < records[map2]?.getRatioDouble() ?? 0.0
            
        }
        return maps.last ?? -1
    }
    
    func getWorstMap (records :[ Int:Stats] )  -> Int {
        
        let maps = records.keys.sorted { (map1, map2) -> Bool in
            return records[map1]?.getRatioDouble() ?? 0.0 < records[map2]?.getRatioDouble() ?? 0.0
        }
        return maps.first ?? -1
    }
    
    
    
    func getMapStats(matches:[Match], game:String, competitive:Bool, gameMode:Int = -2) -> [Int:Stats]   {
        var mapStats:[Int:Stats] = [Int:Stats]()
        
        let filteredMatches = matches
            .filter{$0.competitive == competitive}
            .filter{$0.codGame == game}
            .filter{
                if gameMode >= 0 {
                    return  $0.gameMode == gameMode
                }
                else if gameMode == -2  { // -2 is all for now
                    return true
                }
                else {
                    return true
                }
            }
        
        
        
        for match in filteredMatches {
            
            if competitive == true {
                if !shouldCountMatch(match: match){
                    continue
                }
            }
            
            if let map = match.map, let mapInt = Int(map) {
                
                if mapStats[mapInt] == nil {
                    mapStats[mapInt] = Stats(totalWins: 0, totalLosses: 0)
                }
                
                if match.win {
                    
                    mapStats[mapInt]?.totalWins += 1
                }
                else{
                    mapStats[mapInt]?.totalLosses += 1
                }
            }
            
        }
        return mapStats
    }
    
    func statsWithPlayer(db: Database, playerId:Int)  -> EventLoopFuture<Stats> {
        return Match.query(on: db)
            .filter(\.$players ~~ "\(playerId)")
            .all().map { (matches) -> (Stats) in
                return self.getCountedMatches(matches: matches)
            }
        
    }
    
    func statsWithoutPlayer (db: Database, playerId:Int)  -> EventLoopFuture<Stats> {
        return Match.query(on: db)
            .filter(\.$players !~ "\(playerId)")
            .all().map { (matches) -> (Stats) in
                return self.getCountedMatches(matches: matches)
            }
    }
    
    
    
    
    private func getDaysPlayed(req:Request) -> EventLoopFuture<[CODDate]> {
        
        return Match.query(on: req.db).sort(\.$date, .descending).all().map { (matches) -> ([CODDate]) in
            return matches.map { (match) -> CODDate in
                return CODDate(month: match.date.month, year: match.date.year, day: match.date.day, hour: match.date.hour, minute: match.date.minute)
            }.reduce([CODDate]()) { (datesPlayed, codDate) -> [CODDate] in
                
                if datesPlayed.contains(where: { (existingDate) -> Bool in
                    if codDate.month == existingDate.month && codDate.year == existingDate.year && existingDate.day == codDate.day{
                        return true
                    }
                    return false
                }){
                    return datesPlayed
                }else {
                    
                    return  datesPlayed + [codDate]
                }
            }
        }
    }
    
    
    func allDaily(req:Request) -> EventLoopFuture<AllDailyStats>{
        
        return getDaysPlayed(req: req).flatMap { (previousDays) ->  (EventLoopFuture<AllDailyStats>) in
            
            func getDailyStats (_ remaining: ArraySlice<CODDate>, allDailyStats: inout [DailyStats],  eventLoop: EventLoop) -> EventLoopFuture<[DailyStats]> {
                var remaining = remaining
                if let first = remaining.popLast() {
                    
                    return self.getStatsForDay(year: first.year, month: first.month, day:first.day,  req: req).flatMap { [remaining, allDailyStats] (stats) -> EventLoopFuture<[DailyStats]> in
                        var allDailyStats = allDailyStats
                        
                        let totalWins = allDailyStats.reduce(Double(stats.totalWins)) { (total, dailyStats) -> Double in
                            return total + Double(dailyStats.stats.totalWins)                    }
                        
                        let totalLosses = allDailyStats.reduce(Double(stats.totalLosses)) { (total, dailyStats) -> Double in
                            return total + Double(dailyStats.stats.totalLosses)
                        }
                        
                        allDailyStats.append(DailyStats(day: first.day, month: first.month, year: first.year, stats: stats, cumulativeRatio: self.getRatio(num: totalWins, den: totalLosses)))
                        return getDailyStats(remaining, allDailyStats:&allDailyStats,  eventLoop: eventLoop)
                    }
                    
                } else {
                    return req.eventLoop.makeSucceededFuture(allDailyStats)
                }
            }
            
            
            var stats:[DailyStats] = []
            let dailyStats = getDailyStats(Array(previousDays)[0..<previousDays.count], allDailyStats:&stats, eventLoop: req.eventLoop)
            
            return  dailyStats.map {  (dailyStats) -> AllDailyStats in
                return AllDailyStats(dailyStats: dailyStats.filter({ (dailyStats) -> Bool in
                    
                    if dailyStats.stats.totalWins == 0 && dailyStats.stats.totalLosses == 0 {
                        return false
                    }
                    return true
                }).reversed()
                                     
                )
            }
        }
    }
    
    private func getRatio( num:Double, den:Double) -> String {
        
        var returnString = ""
        let deno = (den != 0) ? den : 1
        
        returnString = String((Double(num) / Double(deno)).truncate(places: 2))
        
        if den == 0 {
            returnString = returnString + "+"
        }
        return returnString
        
    }
    
    
    func getCumulativeWinLossRatios(req:Request) -> EventLoopFuture<[DataPoint]> {
        
        return getDaysPlayed(req: req).flatMap { (previousDays) ->  (EventLoopFuture<[DataPoint]>) in
            
            func getRatios (_ remaining: ArraySlice<CODDate>, allDailyStats: inout [DailyStats], cumulativeWinLossRatios: inout [DataPoint], eventLoop: EventLoop) -> EventLoopFuture<[DataPoint]> {
                var remaining = remaining
                if let first = remaining.popLast() {
                    
                    return self.getStatsForDay(year: first.year, month: first.month, day:first.day,  req: req).flatMap { [remaining, allDailyStats, cumulativeWinLossRatios] (stats) -> EventLoopFuture<[DataPoint]> in
                        var allDailyStats = allDailyStats
                        
                        let totalWins = allDailyStats.reduce(Double(stats.totalWins)) { (total, dailyStats) -> Double in
                            return total + Double(dailyStats.stats.totalWins)                    }
                        
                        let totalLosses = allDailyStats.reduce(Double(stats.totalLosses)) { (total, dailyStats) -> Double in
                            return total + Double(dailyStats.stats.totalLosses)
                        }
                        
                        var cumulativeWinLossRatios = cumulativeWinLossRatios
                        if !(stats.totalWins == 0 && stats.totalLosses == 0) {
                            
                            let date = self.createDate(day: first.day, month: first.month, year: first.year, hour: first.hour + 6, minute:first.minute) // 6 hours to make sure we pick a time that isnt  on borders of us time zones
                            // //print ("p \(date.timeIntervalSince1970)")
                            let x = Double(cumulativeWinLossRatios.count)
                            
                            let d = Date(timeIntervalSince1970: date.timeIntervalSince1970)
                            cumulativeWinLossRatios.append(DataPoint(x:x , y: (totalWins/totalLosses).truncate(places: 2), label:("\(Utilities.monthToString(month: d.month)) \(d.day)")))
                        }
                        allDailyStats.append(DailyStats(day: first.day, month: first.month, year: first.year, stats: stats, cumulativeRatio: self.getRatio(num: totalWins, den: totalLosses)))
                        return getRatios(remaining, allDailyStats:&allDailyStats,  cumulativeWinLossRatios:&cumulativeWinLossRatios, eventLoop: eventLoop)
                    }
                    
                } else {
                    return req.eventLoop.makeSucceededFuture(cumulativeWinLossRatios)
                }
            }
            
            var stats:[DailyStats] = []
            var cumulativeWinLossRatios:[DataPoint] = [DataPoint]()
            
            
            return getRatios(Array(previousDays)[0..<previousDays.count], allDailyStats: &stats, cumulativeWinLossRatios: &cumulativeWinLossRatios, eventLoop: req.eventLoop)
        }
    }
}