games.py

from typing import List
from constants import *
from constants import Station, getMeanOfScoringCategory
from database import *
from pymongo.collection import Collection
import time
import ast
from database import Station, getMeanOfScoringCategory


class Game:
    """
    Game Superclass

    This shouldn't be used; all functions should be replaced.
    """

    def __init__(self, matches: Collection, teams: Collection):
        self.keyDisplayNames = {}
        self.matches = matches
        self.teams = teams
        self.teamRankOptions = {}
        self.teamTableDisplayNames = {}
        self.matchTableDisplayNames = {}
        self.cannedComments = []
        self.pitScoutAutoCapabilities = tuple()
        self.pitScoutTeleCapabilities = tuple()
        raise NotImplementedError("Game Superclass __init__ used")

    def calculateScore(self) -> int:
        """
        Calculate the total score from scouted values.

        This shouldn't be used; replace this with a game specific function.

        Inputs:
        - Depends

        Outputs:
        - int: total score, minus points from fouls

        """
        raise NotImplementedError("Game Superclass calculateScore used")
        # return 0

    def scoreRobotInMatch(self) -> bool:
        """
        Scores one robot in a match.

        This shouldn't be used; replace this with a game specific function.

        Inputs:
        - self explanitory

        Returns:
        - Boolean: if the robot was successfully scored
        """
        raise NotImplementedError("Game Superclass scoreRobotInMatch used")
        # return False

    def calculateScoreFromData(
        self, matchData: dict, team: Station, edit: int = -1
    ) -> int:
        """
        Gets a robot's result from the database and scores it.

        This shouldn't be used; replace this with a game specific function.

        Inputs:
        - matchData (dict): a match dict
        - team (Station): the station to score
        - edit (int): which revision to score, defaults to the latest

        Returns:
        - int: calculated score
        """
        raise NotImplementedError("Game Superclass calculateScoreFromData used")
        # return 0

    def calculateAverageAllianceScore(
        self, team1: int, team2: int, team3: int, calc=getMeanOfScoringCategory
    ) -> dict | None:
        """
        Calculates a hypothetical alliance score of three teams using their average results in each category.

        This shouldn't be used; replace this with a game specific function.

        Inputs:
        - team1 (int): team number 1
        - team2 (int): team number 2
        - team3 (int): team number 3
        - calc (function): the static function to use, defaults to mean

        Returns:
        - dict or none: dict of predicted results, or None if any teams are not found.
        """
        raise NotImplementedError("Game Superclass calculateAverageAllianceScore used")
        # return None

    def calculateMinMaxAllianceScore(
        self, team1: int, team2: int, team3: int, maximum: bool = True
    ) -> dict | None:
        """
        Calculates a hypothetical alliance score of three teams using their minimum or maximum results in each category.

        This shouldn't be used; replace this with a game specific function.

        Inputs:
        - team1 (int): team number 1
        - team2 (int): team number 2
        - team3 (int): team number 3
        - maximum (bool): True uses maximum, False uses minimum, defaults to True

        Returns:
        - dict or none: dict of predicted results, or None if any teams are not found.
        """
        raise NotImplementedError("Game Superclass calcualteMinMaxAllianceScore used")
        # return None

    def getAllStats(self, team: int) -> dict:
        """
        Calculates all stats for every single scoring category.

        This shouldn't be used; replace this with a game specific function.

        Inputs:
        - team (int): Team number

        Returns:
        - dict: dict of every scoring category with every stat
        """
        raise NotImplementedError("Game Superclass getAllStats used")
        # return {}

    def calculateAllianceFromMatches(
        self,
        team1: int,
        match1: list,
        team2: int,
        match2: list,
        team3: int,
        match3: list,
    ) -> dict:
        """
        Adds together results for three teams from given match data to predict their performance as an alliance.

        This shouldn't be used; replace this with a game specific function.

        Inputs:
        - team1 (int): team 1 number
        - match1 (list): match data for team 1
        - team2 (int): team 2 number
        - match2 (list): match data for team 2
        - team3 (int): team 3 number
        - match3 (list): match data for team 3

        Returns:
        - dict: predicted results dict
        """
        raise NotImplementedError("Game Superclass calculateAllianceFromMatches used")
        # return {}

    def calculateStatMatrix(self,team:int) -> dict:
        """
        Calculates a team's stat matrix, with each field from a range from 0 to 1.
        1 represents the highest value for that field.
        
        This shouldn't be used; replace this with a game specific function.

        Inputs:
        - team (int): team number

        Returns:
        - dict: stat dict
        """
        raise NotImplementedError("Game Superclass calculateStatMatrix used")



class Reefscape(Game):
    def __init__(self, matches: Collection, teams: Collection):
        self.keyDisplayNames = {
            "matchNumber": "Match Number",
            "setNumber": "Set Number",
            "compLevel": "Competition Level",
            "matchKey": "Match Key",
            "displayName": "Display Name",
            "teams": "Teams",
            "red1": "Red 1",
            "red2": "Red 2",
            "red3": "Red 3",
            "blue1": "Blue 1",
            "blue2": "Blue 2",
            "blue3": "Blue 3",
            "results": "Results",
            "scored": "Scored",
            "startPos": "Starting Position",
            "autoLeave": "Auto Leave",
            "autoReef": "Reef Auto",
            "autoReefL1": "Reef Auto L1",
            "autoReefL2": "Reef Auto L2",
            "autoReefL3": "Reef Auto L3",
            "autoReefL4": "Reef Auto L4",
            "autoReefMiss": "Reef Auto Missed",
            "teleReef": "Reef Tele-Op",
            "teleReefL1": "Reef Tele-Op L1",
            "teleReefL2": "Reef Tele-Op L2",
            "teleReefL3": "Reef Tele-Op L3",
            "teleReefL4": "Reef Tele-Op L4",
            "teleReefMiss": "Reef Tele-Op Missed",
            "autoProcessor": "Processor Auto",
            "autoProcessorMiss": "Processor Auto Missed",
            "teleProcessor": "Processor Tele-Op",
            "teleProcessorMiss": "Processor Tele-Op Missed",
            "autoNet": "Net Auto",
            "autoNetMiss": "Net Auto Missed",
            "teleNet": "Net Tele-Op",
            "teleNetMiss": "Net Tele-Op Missed",
            "endPos": "Ending Position",
            "attemptedEndPos": "Attempted Ending Position",
            "endPosSuccess": "Succeeded End Position",
            "minorFouls": "Minor Fouls",
            "majorFouls": "Major Fouls",
            "score": "Score Impact",
            "comment": "Comment",
            "scout": "Scout",
        }
        self.matches = matches
        self.teams = teams
        self.teamRankOptions = {
            "Score Impact": "score,0",
            "Starting Position": "startPos,0",
            "Auto Leave": "autoLeave,0",
            "Reef Auto": "autoReef,0",
            "Reef Auto L1": "autoReef,0",
            "Reef Auto L2": "autoReef,1",
            "Reef Auto L3": "autoReef,2",
            "Reef Auto L4": "autoReef,3",
            "Reef Auto Missed": "autoReefMiss,0",
            "Reef Tele-Op": "teleReef,0",
            "Reef Tele-Op L1": "teleReef,0",
            "Reef Tele-Op L2": "teleReef,1",
            "Reef Tele-Op L3": "teleReef,2",
            "Reef Tele-Op L4": "teleReef,3",
            "Reef Tele-Op Missed": "teleReefMiss,0",
            "Processor Auto": "autoProcessor,0",
            "Processor Auto Missed": "autoProcessorMiss,0",
            "Processor Tele-Op": "teleProcessor,0",
            "Processor Tele-Op Missed": "teleProcessorMiss,0",
            "Net Auto": "autoNet,0",
            "Net Auto Missed": "autoNetMiss,0",
            "Net Tele-Op": "teleNet,0",
            "Net Tele-Op Missed": "teleNetMiss,0",
            "Ending Position": "endPos,0",
            "Attempted Ending Position": "attemptedEndPos,0",
            "Minor Fouls": "minorFouls,0",
            "Major Fouls": "majorFouls,0",
        }
        self.teamTableDisplayNames = {
            "score": "Score Impact",
            "autoLeave": "Auto Leave",
            "autoReefL1": "Reef Auto L1",
            "autoReefL2": "Reef Auto L2",
            "autoReefL3": "Reef Auto L3",
            "autoReefL4": "Reef Auto L4",
            "autoReefMiss": "Reef Auto Missed",
            "autoReefTotal": "Reef Auto Total",
            "teleReefL1": "Reef Tele-Op L1",
            "teleReefL2": "Reef Tele-Op L2",
            "teleReefL3": "Reef Tele-Op L3",
            "teleReefL4": "Reef Tele-Op L4",
            "teleReefMiss": "Reef Tele-Op Missed",
            "teleReefTotal": "Reef Tele-Op Total",
            "autoProcessor": "Processor Auto",
            "autoProcessorMiss": "Processor Auto Missed",
            "teleProcessor": "Processor Tele-Op",
            "teleProcessorMiss": "Processor Tele-Op Missed",
            "autoNet": "Net Auto",
            "autoNetMiss": "Net Auto Missed",
            "teleNet": "Net Tele-Op",
            "teleNetMiss": "Net Tele-Op Missed",
            "minorFouls": "Minor Fouls",
            "majorFouls": "Major Fouls",
        }
        self.matchTableDisplayNames = {
            "team": "Team",
            "displayName": "Display Name",
            "score": "Score Impact",
            "matchNumber": "Match Number",
            "setNumber": "Set Number",
            "compLevel": "Competition Level",
            "startPos": "Starting Position",
            "autoLeave": "Auto Leave",
            "autoReefL1": "Reef Auto L1",
            "autoReefL2": "Reef Auto L2",
            "autoReefL3": "Reef Auto L3",
            "autoReefL4": "Reef Auto L4",
            "autoReefMiss": "Reef Auto Missed",
            "teleReefL1": "Reef Tele-Op L1",
            "teleReefL2": "Reef Tele-Op L2",
            "teleReefL3": "Reef Tele-Op L3",
            "teleReefL4": "Reef Tele-Op L4",
            "teleReefMiss": "Reef Tele-Op Missed",
            "autoProcessor": "Processor Auto",
            "autoProcessorMiss": "Processor Auto Missed",
            "teleProcessor": "Processor Tele-Op",
            "teleProcessorMiss": "Processor Tele-Op Missed",
            "autoNet": "Net Auto",
            "autoNetMiss": "Net Auto Missed",
            "teleNet": "Net Tele-Op",
            "teleNetMiss": "Net Tele-Op Missed",
            "attemptedEndPos": "Attempted Ending Position",
            "endPosSuccess": "Ending Position Sucecss",
            "minorFouls": "Minor Fouls",
            "majorFouls": "Major Fouls",
            "comment": "Comment",
        }
        self.cannedComments = [
            "Good Driving",
            "Bad Driving",
            "Fast Driving",
            "Slow Driving",
            "Removed Algae",
            "Coral Station During Auto",
            "Played Defense",
            "Good Defense",
            "Bad Defense",
            "Was Defended",
            "Multiple Fouls",
            "Multiple Jams",
            "Bumpers Off",
            "Tipped/Stuck",
            "Died",
            "No Show",
            "Bad Descision Making",
        ]
        self.pitScoutAutoCapabilities = tuple()
        self.pitScoutTeleCapabilities = tuple()

    def calculateScore(
        self,
        autoLeave: bool,
        autoReef: List[int],
        teleReef: List[int],
        autoProcessor: int,
        teleProcessor: int,
        autoNet: int,
        teleNet: int,
        endPos: int,
        minorFouls: int,
        majorFouls: int,
    ) -> int:
        """
        Calculate the total score from scouted values.

        Inputs:
        - Self explanatory

        Outputs:
        - int: total score, minus points from fouls

        """
        score = 0

        score += 3 if autoLeave else 0

        score += 3 * autoReef[0]
        score += 4 * autoReef[1]
        score += 6 * autoReef[2]
        score += 7 * autoReef[3]

        score += 2 * teleReef[0]
        score += 3 * teleReef[1]
        score += 4 * teleReef[2]
        score += 5 * teleReef[3]

        score += 2 * autoProcessor
        score += 2 * teleProcessor

        score += 4 * autoNet
        score += 4 * teleNet

        score += (
            2
            if endPos == EndPositionReefscape.PARK.value
            else (
                6
                if endPos == EndPositionReefscape.SHALLOW.value
                else 12 if endPos == EndPositionReefscape.DEEP.value else 0
            )
        )

        score -= 2 * minorFouls
        score -= 6 * majorFouls

        return score

    def scoreRobotInMatch(
        self,
        matchNumber: int,
        setNumber: int,
        compLevel: CompLevel,
        station: Station,
        startPos: StartingPosition,
        autoLeave: bool,
        autoReef: List[int],
        autoReefMiss: int,
        teleReef: List[int],
        teleReefMiss: int,
        autoProcessor: int,
        autoProcessorMiss: int,
        teleProcessor: int,
        teleProcessorMiss: int,
        autoNet: int,
        autoNetMiss: int,
        teleNet: int,
        teleNetMiss: int,
        endPosSuccess: bool,
        attemptedEndPos: EndPositionReefscape,
        minorFouls: int,
        majorFouls: int,
        comment: str,
        cannedComments: List[str],
        scout: str,
    ) -> bool:
        """
        Scores one robot in a match.

        Should change every year.

        Inputs:
        - self explanitory

        Returns:
        - Boolean: if the robot was successfully scored
        """
        result = matches.update_many(
            {
                "matchNumber": matchNumber,
                "setNumber": setNumber,
                "compLevel": compLevel.value,
            },
            {
                "$push": {
                    "results."
                    + station.value: {
                        "startPos": startPos.value,
                        "autoLeave": autoLeave,
                        "autoReef": autoReef,
                        "autoReefMiss": autoReefMiss,
                        "autoReefTotal": autoReef[0]
                        + autoReef[1]
                        + autoReef[2]
                        + autoReef[3],
                        "teleReef": teleReef,
                        "teleReefMiss": teleReefMiss,
                        "teleReefTotal": teleReef[0]
                        + teleReef[1]
                        + teleReef[2]
                        + teleReef[3],
                        "autoProcessor": autoProcessor,
                        "autoProcessorMiss": autoProcessorMiss,
                        "teleProcessor": teleProcessor,
                        "teleProcessorMiss": teleProcessorMiss,
                        "autoNet": autoNet,
                        "autoNetMiss": autoNetMiss,
                        "teleNet": teleNet,
                        "teleNetMiss": teleNetMiss,
                        "endPosSuccess": endPosSuccess,
                        "attemptedEndPos": attemptedEndPos.value,
                        "minorFouls": minorFouls,
                        "majorFouls": majorFouls,
                        "score": self.calculateScore(
                            autoLeave,
                            autoReef,
                            teleReef,
                            autoProcessor,
                            teleProcessor,
                            autoNet,
                            teleNet,
                            (
                                attemptedEndPos.value
                                if endPosSuccess
                                else EndPositionReefscape.NONE.value
                            ),
                            minorFouls,
                            majorFouls,
                        ),
                        "comment": comment,
                        "cannedComments": cannedComments,
                        "scout": scout,
                    }
                }
            },
        )
        if result.matched_count == 0:
            app.logger.info(  # type: ignore
                f"Failed to score robot {station.value} for match {matchNumber} by {scout}: Match does not exist."
            )
            return False
        writeToCacheFile("","statMatrixCache")
        app.logger.info(f"Robot {station.value} scored for match {matchNumber} by {scout}.")  # type: ignore
        return True

    def calculateScoreFromData(
        self, matchData: dict, team: Station, edit: int = -1
    ) -> int:
        """
        Gets a robot's result from the database and scores it.

        Inputs:
        - matchData (dict): a match dict
        - team (Station): the station to score
        - edit (int): which revision to score, defaults to the latest

        Returns:
        - int: calculated score
        """
        results = matchData["results"][team.value][edit]
        score = self.calculateScore(
            results["autoLeave"],
            results["autoReef"],
            results["teleReef"],
            results["autoProcessor"],
            results["teleProcessor"],
            results["autoNet"],
            results["teleNet"],
            results["endPos"],
            results["minorFouls"],
            results["majorFouls"],
        )
        return score

    def calculateAverageAllianceScore(
        self, team1: int, team2: int, team3: int, calc=getMeanOfScoringCategory
    ):
        """
        Calculates a hypothetical alliance score of three teams using their average results in each category.

        Should be edited every year.

        Inputs:
        - team1 (int): team number 1
        - team2 (int): team number 2
        - team3 (int): team number 3
        - calc (function): the static function to use, defaults to mean

        Returns:
        - dict or none: dict of predicted results, or None if any teams are not found.
        """
        team1Listing = getTeam(team1)
        if not team1Listing:
            return None
        team2Listing = getTeam(team2)
        if not team2Listing:
            return None
        team3Listing = getTeam(team3)
        if not team3Listing:
            return None

        team1Data = getTeamResults(team1)
        team2Data = getTeamResults(team2)
        team3Data = getTeamResults(team3)

        team1Leave = int(calc(team1Data, "autoLeave") >= 0.5)
        team2Leave = int(calc(team2Data, "autoLeave") >= 0.5)
        team3Leave = int(calc(team3Data, "autoLeave") >= 0.5)
        leaveTotal = team1Leave + team2Leave + team3Leave

        team1End = round(calc(team1Data, "endPos"))
        team2End = round(calc(team2Data, "endPos"))
        team3End = round(calc(team3Data, "endPos"))

        team1Minors = calc(team1Data, "minorFouls")
        team2Minors = calc(team2Data, "minorFouls")
        team3Minors = calc(team3Data, "minorFouls")

        team1Majors = calc(team1Data, "majorFouls")
        team2Majors = calc(team2Data, "majorFouls")
        team3Majors = calc(team3Data, "majorFouls")

        autoReef = [
            round(calc(team1Data, "autoReef", 0))
            + round(calc(team2Data, "autoReef", 0))
            + round(calc(team3Data, "autoReef", 0)),
            round(calc(team1Data, "autoReef", 1))
            + round(calc(team2Data, "autoReef", 1))
            + round(calc(team3Data, "autoReef", 1)),
            round(calc(team1Data, "autoReef", 2))
            + round(calc(team2Data, "autoReef", 2))
            + round(calc(team3Data, "autoReef", 2)),
            round(calc(team1Data, "autoReef", 3))
            + round(calc(team2Data, "autoReef", 3))
            + round(calc(team3Data, "autoReef", 3)),
        ]

        autoReef[0] += (
            (max(autoReef[1], 12) - 12)
            + (max(autoReef[2], 12) - 12)
            + (max(autoReef[3], 12) - 12)
        )

        autoReef = [
            autoReef[0],
            min(autoReef[1], 12),
            min(autoReef[2], 12),
            min(autoReef[3], 12),
        ]

        teleReefValues = [
            round(calc(team1Data, "teleReef", 0))
            + round(calc(team2Data, "teleReef", 0))
            + round(calc(team3Data, "teleReef", 0)),
            round(calc(team1Data, "teleReef", 1))
            + round(calc(team2Data, "teleReef", 1))
            + round(calc(team3Data, "teleReef", 1)),
            round(calc(team1Data, "teleReef", 2))
            + round(calc(team2Data, "teleReef", 2))
            + round(calc(team3Data, "teleReef", 2)),
            round(calc(team1Data, "teleReef", 3))
            + round(calc(team2Data, "teleReef", 3))
            + round(calc(team3Data, "teleReef", 3)),
        ]

        teleReef = [
            teleReefValues[0],
            min(teleReefValues[1], 12 - autoReef[1]),
            min(teleReefValues[1], 12 - autoReef[1]),
            min(teleReefValues[1], 12 - autoReef[1]),
        ]
        teleReef[0] += (
            max(0, teleReefValues[1] - teleReef[1])
            + max(0, teleReefValues[2] - teleReef[2])
            + max(0, teleReefValues[3] - teleReef[3])
        )

        autoProcessor = (
            round(calc(team1Data, "autoProcessor"))
            + round(calc(team2Data, "autoProcessor"))
            + round(calc(team3Data, "autoProcessor"))
        )
        teleProcessor = (
            round(calc(team1Data, "teleProcessor"))
            + round(calc(team2Data, "teleProcessor"))
            + round(calc(team3Data, "teleProcessor"))
        )

        autoNet = (
            round(calc(team1Data, "autoNet"))
            + round(calc(team2Data, "autoNet"))
            + round(calc(team3Data, "autoNet"))
        )
        teleNet = (
            round(calc(team1Data, "teleNet"))
            + round(calc(team2Data, "teleNet"))
            + round(calc(team3Data, "teleNet"))
        )

        score = self.calculateScore(
            False,
            autoReef,
            teleReef,
            autoProcessor,
            teleProcessor,
            autoNet,
            teleNet,
            0,
            0,
            0,
        )

        score += 3 * leaveTotal
        score += (
            2
            if team1End == EndPositionReefscape.PARK.value
            else (
                6
                if team1End == EndPositionReefscape.SHALLOW.value
                else 12 if team1End == EndPositionReefscape.DEEP.value else 0
            )
        )
        score += (
            2
            if team2End == EndPositionReefscape.PARK.value
            else (
                6
                if team2End == EndPositionReefscape.SHALLOW.value
                else 12 if team2End == EndPositionReefscape.DEEP.value else 0
            )
        )
        score += (
            2
            if team3End == EndPositionReefscape.PARK.value
            else (
                6
                if team3End == EndPositionReefscape.SHALLOW.value
                else 12 if team3End == EndPositionReefscape.DEEP.value else 0
            )
        )

        return {
            "score": score,
            "autoLeave": leaveTotal,
            "autoReef": autoReef,
            "teleReef": teleReef,
            "autoProcessor": autoProcessor,
            "teleProcessor": teleProcessor,
            "autoNet": autoNet,
            "teleNet": teleNet,
            "endPos1": team1End,
            "endPos2": team2End,
            "endPos3": team3End,
            "minorFouls": team1Minors + team2Minors + team3Minors,
            "majorFouls": team1Majors + team2Majors + team3Majors,
        }

    def calculateMinMaxAllianceScore(
        self, team1: int, team2: int, team3: int, maximum: bool = True
    ):
        """
        Calculates a hypothetical alliance score of three teams using their minimum or maximum results in each category.

        Inputs:
        - team1 (int): team number 1
        - team2 (int): team number 2
        - team3 (int): team number 3
        - maximum (bool): True uses maximum, False uses minimum, defaults to True

        Returns:
        - dict or none: dict of predicted results, or None if any teams are not found.
        """
        statistic = getMatchWithHighestValue if maximum else getMatchWithLowestValue
        oppositeStatistic = (
            getMatchWithLowestValue if maximum else getMatchWithHighestValue
        )

        team1Listing = getTeam(team1)
        if not team1Listing:
            return None
        team2Listing = getTeam(team2)
        if not team2Listing:
            return None
        team3Listing = getTeam(team3)
        if not team3Listing:
            return None

        team1Data = getTeamResults(team1)
        team2Data = getTeamResults(team2)
        team3Data = getTeamResults(team3)

        team1Leave = statistic(team1Data, "autoLeave")["value"]
        team2Leave = statistic(team2Data, "autoLeave")["value"]
        team3Leave = statistic(team3Data, "autoLeave")["value"]
        leaveTotal = team1Leave + team2Leave + team3Leave

        team1End = statistic(team1Data, "endPos")["value"]
        team2End = statistic(team2Data, "endPos")["value"]
        team3End = statistic(team3Data, "endPos")["value"]

        team1Minors = statistic(team1Data, "minorFouls")["value"]
        team2Minors = statistic(team2Data, "minorFouls")["value"]
        team3Minors = statistic(team3Data, "minorFouls")["value"]

        team1Majors = statistic(team1Data, "majorFouls")["value"]
        team2Majors = statistic(team2Data, "majorFouls")["value"]
        team3Majors = statistic(team3Data, "majorFouls")["value"]

        autoReef = [
            round(statistic(team1Data, "autoReef", 0)["value"])
            + round(statistic(team2Data, "autoReef", 0)["value"])
            + round(statistic(team3Data, "autoReef", 0)["value"]),
            round(statistic(team1Data, "autoReef", 1)["value"])
            + round(statistic(team2Data, "autoReef", 1)["value"])
            + round(statistic(team3Data, "autoReef", 1)["value"]),
            round(statistic(team1Data, "autoReef", 2)["value"])
            + round(statistic(team2Data, "autoReef", 2)["value"])
            + round(statistic(team3Data, "autoReef", 2)["value"]),
            round(statistic(team1Data, "autoReef", 3)["value"])
            + round(statistic(team2Data, "autoReef", 3)["value"])
            + round(statistic(team3Data, "autoReef", 3)["value"]),
        ]

        autoReef[0] += (
            (max(autoReef[1], 12) - 12)
            + (max(autoReef[2], 12) - 12)
            + (max(autoReef[3], 12) - 12)
        )

        autoReef = [
            autoReef[0],
            min(autoReef[1], 12),
            min(autoReef[2], 12),
            min(autoReef[3], 12),
        ]

        teleReefValues = [
            round(statistic(team1Data, "teleReef", 0)["value"])
            + round(statistic(team2Data, "teleReef", 0)["value"])
            + round(statistic(team3Data, "teleReef", 0)["value"]),
            round(statistic(team1Data, "teleReef", 1)["value"])
            + round(statistic(team2Data, "teleReef", 1)["value"])
            + round(statistic(team3Data, "teleReef", 1)["value"]),
            round(statistic(team1Data, "teleReef", 2)["value"])
            + round(statistic(team2Data, "teleReef", 2)["value"])
            + round(statistic(team3Data, "teleReef", 2)["value"]),
            round(statistic(team1Data, "teleReef", 3)["value"])
            + round(statistic(team2Data, "teleReef", 3)["value"])
            + round(statistic(team3Data, "teleReef", 3)["value"]),
        ]

        teleReef = [
            teleReefValues[0],
            min(teleReefValues[1], 12 - autoReef[1]),
            min(teleReefValues[1], 12 - autoReef[1]),
            min(teleReefValues[1], 12 - autoReef[1]),
        ]
        teleReef[0] += (
            max(0, teleReefValues[1] - teleReef[1])
            + max(0, teleReefValues[2] - teleReef[2])
            + max(0, teleReefValues[3] - teleReef[3])
        )

        autoProcessor = (
            statistic(team1Data, "autoProcessor")["value"]
            + statistic(team2Data, "autoProcessor")["value"]
            + statistic(team3Data, "autoProcessor")["value"]
        )
        teleProcessor = (
            statistic(team1Data, "teleProcessor")["value"]
            + statistic(team2Data, "teleProcessor")["value"]
            + statistic(team3Data, "teleProcessor")["value"]
        )

        autoNet = (
            statistic(team1Data, "autoNet")["value"]
            + statistic(team2Data, "autoNet")["value"]
            + statistic(team3Data, "autoNet")["value"]
        )
        teleNet = (
            statistic(team1Data, "teleNet")["value"]
            + statistic(team2Data, "teleNet")["value"]
            + statistic(team3Data, "teleNet")["value"]
        )

        score = self.calculateScore(
            False,
            autoReef,
            teleReef,
            autoProcessor,
            teleProcessor,
            autoNet,
            teleNet,
            0,
            0,
            0,
        )

        score += 3 * leaveTotal
        score += (
            2
            if team1End == EndPositionReefscape.PARK.value
            else (
                6
                if team1End == EndPositionReefscape.SHALLOW.value
                else 12 if team1End == EndPositionReefscape.DEEP.value else 0
            )
        )
        score += (
            2
            if team2End == EndPositionReefscape.PARK.value
            else (
                6
                if team2End == EndPositionReefscape.SHALLOW.value
                else 12 if team2End == EndPositionReefscape.DEEP.value else 0
            )
        )
        score += (
            2
            if team3End == EndPositionReefscape.PARK.value
            else (
                6
                if team3End == EndPositionReefscape.SHALLOW.value
                else 12 if team3End == EndPositionReefscape.DEEP.value else 0
            )
        )

        return {
            "score": score,
            "autoLeave": leaveTotal,
            "autoReef": autoReef,
            "teleReef": teleReef,
            "autoProcessor": autoProcessor,
            "teleProcessor": teleProcessor,
            "autoNet": autoNet,
            "teleNet": teleNet,
            "endPos1": team1End,
            "endPos2": team2End,
            "endPos3": team3End,
            "minorFouls": team1Minors + team2Minors + team3Minors,
            "majorFouls": team1Majors + team2Majors + team3Majors,
        }

    def getAllStats(self, team: int) -> dict:
        """
        Calculates all stats for every single scoring category.

        Inputs:
        - team (int): Team number

        Returns:
        - dict: dict of every scoring category with every stat
        """
        teamResults = getTeamResults(team)
        return {
            "startPos": getAllStatsForCategory(teamResults, "startPos"),
            "autoLeave": getAllStatsForCategory(teamResults, "autoLeave"),
            "autoReefL1": getAllStatsForCategory(teamResults, "autoReef", 0),
            "autoReefL2": getAllStatsForCategory(teamResults, "autoReef", 1),
            "autoReefL3": getAllStatsForCategory(teamResults, "autoReef", 2),
            "autoReefL4": getAllStatsForCategory(teamResults, "autoReef", 3),
            "autoReefMiss": getAllStatsForCategory(teamResults, "autoReefMiss"),
            "teleReefL1": getAllStatsForCategory(teamResults, "teleReef", 0),
            "teleReefL2": getAllStatsForCategory(teamResults, "teleReef", 1),
            "teleReefL3": getAllStatsForCategory(teamResults, "teleReef", 2),
            "teleReefL4": getAllStatsForCategory(teamResults, "teleReef", 3),
            "teleReefMiss": getAllStatsForCategory(teamResults, "teleReefMiss"),
            "autoProcessor": getAllStatsForCategory(teamResults, "autoProcessor"),
            "autoProcessorMiss": getAllStatsForCategory(
                teamResults, "autoProcessorMiss"
            ),
            "teleProcessor": getAllStatsForCategory(teamResults, "teleProcessor"),
            "teleProcessorMiss": getAllStatsForCategory(
                teamResults, "teleProcessorMiss"
            ),
            "autoNet": getAllStatsForCategory(teamResults, "autoNet"),
            "autoNetMiss": getAllStatsForCategory(teamResults, "autoNetMiss"),
            "teleNet": getAllStatsForCategory(teamResults, "teleNet"),
            "teleNetMiss": getAllStatsForCategory(teamResults, "teleNetMiss"),
            "endPosSuccess": getAllStatsForCategory(teamResults, "endPosSuccess"),
            "attemptedEndPos": getAllStatsForCategory(teamResults, "attemptedEndPos"),
            "minorFouls": getAllStatsForCategory(teamResults, "minorFouls"),
            "majorFouls": getAllStatsForCategory(teamResults, "majorFouls"),
            "score": getAllStatsForCategory(teamResults, "score"),
        }


class Rebuilt(Game):
    def __init__(self, matches: Collection, teams: Collection):
        self.keyDisplayNames = {
            "matchNumber": "Match Number",
            "setNumber": "Set Number",
            "compLevel": "Competition Level",
            "preloadFuel": "Preloaded Fuel",
            # "autoFuel": "Auto Fuel",
            "autoFuelTotal": "Total Auto Fuel",
            # "autoFuelTotalMissed": "Total Auto Fuel Missed",
            "autoDepot": "Intaked from Depot During Auto",
            "autoBump": "Went over the Bump in Auto",
            "autoTrench": "Went under the Trench in Auto",
            "autoNeutralIntake": "Intaked from the Neutral Zone during Auto",
            "autoAttemptedSecondScore": "Attempted to score past preloads during Auto",
            "autoSucceededSecondScore": "Succeeded to score past preloads during Auto",
            "autoClimbAttempted": "Auto L1 Climb Attempted",
            "autoClimbSuccess": "Auto L1 Climb Succeeded",
            "autoOutpostFeed": "Fed from the Outpost during Auto",
            "autoFedToOutpost": "Fed to the Outpost during Auto",
            "firstShift": "Active in first and third shifts",
            # "transitionFuel": "Transition Shift Fuel",
            "transitionFuelTotal": "Total Transition Shift Fuel",
            # "transitionFuelTotalMissed": "Total Transition Shift Fuel Missed",
            "transitionFed": "Fed Fuel Into Alliance Zone During Transition Period",
            "transitionDefense": "Defended During Transition Period",
            "transitionStole": "Stole During Transition Period",
            # "firstActiveShiftFuel": "First Active Shift Fuel",
            "firstActiveShiftFuelTotal": "Total First Active Shift Fuel",
            # "firstActiveShiftFuelTotalMissed": "Total First Active Shift Fuel Missed",
            "firstActiveShiftFed": "Fed Fuel Into Alliance Zone During the First Active Shift",
            "firstActiveShiftDefense": "Defended During the First Active Shift",
            "firstActiveShiftStole": "Stole During the First Active Shift",
            # "secondActiveShiftFuel": "Second Active Shift Fuel",
            "secondActiveShiftFuelTotal": "Total Second Active Shift Fuel",
            # "secondActiveShiftFuelTotalMissed": "Total Second Active Shift Fuel Missed",
            "secondActiveShiftFed": "Fed Fuel Into Alliance Zone During the Second Active Shift",
            "secondActiveShiftDefense": "Defended During the Second Active Shift",
            "secondActiveShiftStole": "Stole During the Second Active Shift",
            "firstInactiveShiftScored": "Scored During First Inactive Shift",
            "scoredDuringFirstInactiveShift": "Scored During First Inacgive Shift",
            "firstInactiveShiftFed": "Fed Fuel Into Alliance Zone During First Inactive Shift",
            "firstInactiveShiftDefense": "Defended During First Inactive Shift",
            "firstInactiveShiftStole": "Stole During the First Inactive Shift",
            "firstInactiveShiftIntaked": "Intaked During First Inactive Shift",
            "secondInactiveShiftScored": "Scored During Second Inactive Shift",
            "scoredDuringSecondInactiveShift": "Scored During Second Inactive Shift",
            "secondInactiveShiftFed": "Fed Fuel Into Alliance Zone During Second Inactive Shift",
            "secondInactiveShiftIntaked": "Intaked During Second Inactive Shift",
            "secondInactiveShiftDefense": "Defended During First Inactive Shift",
            "secondInactiveShiftStole": "Stole During the Second Inactive Shift",
            # "endgameFuel": "Endgame Fuel",
            "endgameFuelTotal": "Total Endgame Fuel",
            # "endgameFuelTotalMissed": "Total Endgame Fuel Missed",
            "endgameFed": "Fed Fuel Into Alliance Zone During Endgame",
            "endgameDefense": "Defended During Endgame",
            "endgameStole": "Stole During Endgame",
            "endClimb": "Endgame Climb",
            "endClimbAttempted": "Endgame Climb Attempted",
            "outpostIntake": "Intaked from the Outpost",
            "groundIntake": "Intaked from the ground",
            "fedToOutpost": "Fed to the outpost",
            "totalTeleopFuel": "Total Teleop Fuel Worth Points",
            "totalFuel": "Total Fuel Worth Points",
            # "totalFuelMissed": "Total Fuel Missed",
            "feedingRank":"Feeding Rank",
            "feedingComment":"Feeding Comment",
            "defenseRank":"Defense Rank",
            "defenseComment":"Defense Comment",
            "stealRank": "Stealing Rank",
            "driverRank": "Driver Skill Rank",
            "vibeCheck": "Vibe Check",
            "minorFouls": "Minor Fouls",
            "majorFouls": "Major Fouls",
            "score": "Score Impact",
            "comment": "Comment",
            "cannedComments": "Canned Comments",
            "scout": "Scout",
            # "autoFuelAverageShotPerSecond": "Average Auto Fuel Shot Per Second",
            # "autoFuelAverageScoredPerSecond": "Average Auto Fuel Scored Per Second",
            # "transitionFuelAverageShotPerSecond": "Average Transition Fuel Shot Per Second",
            # "transitionFuelAverageScoredPerSecond": "Average Transition Fuel Scored Per Second",
            # "firstActiveShiftFuelAverageShotPerSecond": "Average First Active Shift Fuel Shot Per Second",
            # "firstActiveShiftFuelAverageScoredPerSecond": "Average First Active Shift Fuel Scored Per Second",
            # "secondActiveShiftFuelAverageShotPerSecond": "Average Second Active Shift Fuel Shot Per Second",
            # "secondActiveShiftFuelAverageScoredPerSecond": "Average Second Active Shift Fuel Scored Per Second",
            # "endgameFuelAverageShotPerSecond": "Average Endgame Fuel Shot Per Second",
            # "endgameFuelAverageScoredPerSecond": "Average Endgame Fuel Scored Per Second",
            # "totalFuelAverageShotPerSecond": "Average Fuel Shot Per Second",
            # "totalFuelAverageScoredPerSecond": "Average Fuel Scored Per Second",
        }
        self.matches = matches
        self.teams = teams
        self.teamRankOptions = {
            "Score Impact": "score,0",
            "Preloaded Fuel": "preloadFuel,0",
            "Auto Fuel Total": "autoFuelTotal,0",  # fuel is special :3
            # "Auto Fuel Missed": "autoFuelMissed,0",
            "Intaked from Depot during Auto": "autoDepot,0",
            "Went over the Bump in Auto": "autoBump,0",
            "Went under the Trench in Auto": "autoTrench,0",
            "Intaked from the Neutral Zone during Auto": "autoNeutralIntake,0",
            "Attempted to score past preloads during Auto": "autoAttemptedSecondScore,0",
            "Succeeded to score past preloads during Auto": "autoSucceededSecondScore,0",
            "Auto L1 Climb Attempted": "autoClimbAttempted,0",
            "Auto L1 Climb Succeeded": "autoClimbSuccess,0",
            "Active in first and third shifts": "firstShift,0",
            # teleop fuel block
            "Transition Shift Fuel Total": "transitionFuelTotal,0",
            "Fed Fuel Into Alliance Zone During Transition Period": "transitionFed,0",
            "Defending During Transition Period": "transitionDefense,0",
            "Stole During Transition Period": "transitionStole,0",
            # "Transition Shift Fuel Missed": "transitionFuelTotalMissed,0",
            "First Active Shift Fuel Total": "firstActiveShiftFuelTotal,0",
            "Fed Fuel Into Alliance Zone During the First Active Shift": "firstActiveShiftFed,0",
            "Defending During the First Active Shift": "firstActiveShiftefense,0",
            "Stole During the First Active Shift": "firstActiveShiftStole,0",
            "Second Active Shift Fuel Total": "secondActiveShiftFuelTotal,0",
            "Fed Fuel Into Alliance Zone During the Second Active Shift": "secondActiveShiftFed,0",
            "Defending During the Second Active Shift": "secondActiveShiftefense,0",
            "Stole During the Second Active Shift": "secondActiveShiftStole,0",
            "Endgame Fuel Total": "endgameFuelTotal,0",
            # "First Active Shift Fuel Missed": "firstActiveShiftFuelMissed,0",
            # "Second Active Shift Fuel Missed": "secondActiveShiftFuelMissed,0",
            # "Endgame Fuel Missed": "endgameFuelMissed,0",
            "Scored During First Inactive Shift": "firstInactiveShiftScored,0",
            "Scored During Second Inactive Shift": "secondInactiveShiftScored,0",
            "Intaked During First Inactive Shift": "firstInactiveShiftIntaked,0",
            "Intaked During Second Inactive Shift": "secondInactiveShiftIntaked,0",
            "Fed Fuel Into Alliance Zone During the First Inactive Shift": "firstInactiveShiftFed,0",
            "Defending During the First Inactive Shift": "firstInactiveShiftefense,0",
            "Stole During the First Inactive Shift": "firstInactiveShiftStole,0",
            "Fed Fuel Into Alliance Zone During the Second Inactive Shift": "secondInactiveShiftFed,0",
            "Defending During the Second Inactive Shift": "secondInactiveShiftefense,0",
            "Stole During the Second Inactive Shift": "secondInactiveShiftStole,0",
            "Stole During Endgame": "endgameStole,0",
            "Endgame Climb": "endClimb,0",
            "Endgame Climb Attempted": "endClimbAttempted,0",
            "Played Defense": "playedDefense,0",
            "Fed to Alliance Zone during Active Shift": "fedToAllianceActive,0",
            "Fed to Alliance Zone during Inactive Shift": "fedToAllianceInactive,0",
            "Intaked from the Outpost": "outpostIntake,0",
            "Intaked from the ground": "groundIntake,0",
            "Total Fuel Worth Points": "totalFuel,0",
            "Total Teleop Fuel Worth Points": "totalTeleopFuel,0",
            # "Total Fuel Missed": "totalFuelMissed,0",
            "Feeding Rank":"feedingRank,0",
            "Defense Rank":"defenseRank,0",
            "Stealing Rank": "stealRank,0",
            "Driver Skill Rank": "driverRank,0",
            "Vibe Check": "vibeCheck,0",
            "Minor Fouls": "minorFouls,0",
            "Major Fouls": "majorFouls,0",
            # "Average Auto Fuel Shot Per Second": "autoFuelAverageShotPerSecond,0",
            # "Average Auto Fuel Scored Per Second": "autoFuelAverageScoredPerSecond,0",
            # "Average Transition Fuel Shot Per Second": "transitionFuelAverageShotPerSecond,0",
            # "Average Transition Fuel Scored Per Second": "transitionFuelAverageScoredPerSecond,0",
            # "Average First Active Shift Fuel Shot Per Second": "firstActiveShiftFuelAverageShotPerSecond,0",
            # "Average First Active Shift Fuel Scored Per Second": "firstActiveShiftFuelAverageScoredPerSecond,0",
            # "Average Second Active Shift Fuel Shot Per Second": "secondActiveShiftFuelAverageShotPerSecond,0",
            # "Average Second Active Shift Fuel Scored Per Second": "secondActiveShiftFuelAverageScoredPerSecond,0",
            # "Average Endgame Fuel Shot Per Second": "endgameFuelAverageShotPerSecond,0",
            # "Average Endgame Fuel Scored Per Second": "endgameFuelAverageScoredPerSecond,0",
            # "Average Fuel Shot Per Second": "totalFuelAverageShotPerSecond,0",
            # "Average Fuel Scored Per Second": "totalFuelAverageScoredPerSecond,0",
        }
        self.teamTableDisplayNames = {
            "score": "Score Impact",
            # "totalFuelAverageScoredPerSecond": "Average Fuel Scored Per Second",
            "totalFuel": "Total Fuel Worth Points",
            "totalTeleopFuel": "Total Teleop Fuel Worth Points",
            # "totalFuelMissed": "Total Fuel Missed",
            "minorFouls": "Minor Fouls",
            "majorFouls": "Major Fouls",
            # "autoFuelAverageScoredPerSecond": "Average Auto Fuel Scored Per Second",
            # "transitionFuelAverageScoredPerSecond": "Average Transition Fuel Scored Per Second",
            # "firstActiveShiftFuelAverageScoredPerSecond": "Average First Active Shift Fuel Scored Per Second",
            # "secondActiveShiftFuelAverageScoredPerSecond": "Average Second Active Shift Fuel Scored Per Second",
            # "endgameFuelAverageScoredPerSecond": "Average Endgame Fuel Scored Per Second",
            "outpostIntake": "Intaked from the Outpost",
            "fedToOutpost": "Fed to the outpost",
            "groundIntake": "Intaked from the ground",
            "preloadFuel": "Preloaded Fuel",
            "autoFuelTotal": "Total Auto Fuel",
            "autoDepot": "Intaked from Depot During Auto",
            "autoBump": "Went over the Bump in Auto",
            "autoTrench": "Went under the Trench in Auto",
            "autoNeutralIntake": "Intaked from the Neutral Zone during Auto",
            "autoAttemptedSecondScore": "Attempted to score past preloads during Auto",
            "autoSucceededSecondScore": "Succeeded to score past preloads during Auto",
            "autoClimbAttempted": "Auto L1 Climb Attempted",
            "autoClimbSuccess": "Auto L1 Climb Succeeded",
            "autoOutpostFeed": "Fed from the Outpost during Auto",
            "autoFedToOutpost": "Fed to the Outpost during Auto",
            "firstShift": "Active in first and third shifts",
            "transitionFuelTotal": "Total Transition Shift Fuel",
            "transitionFed": "Fed during transition shift",
            "transitionDefense": "Defended during transition shift",
            "transitionStole": "Stole During Transition Period",
            "firstActiveShiftFuelTotal": "Total First Active Shift Fuel",
            "firstActiveShiftFed": "Fed to alliance side during first active shift",
            "firstActiveShiftDefense": "Played defense during first active shift",
            "firstActiveShiftStole": "Stole During the First Active Shift",
            "secondActiveShiftFuelTotal": "Total Second Active Shift Fuel",
            "secondActiveShiftFed": "Fed to alliance side during second active shift",
            "secondActiveShiftDefense": "Played defense during second active shift",
            "secondActiveShiftStole": "Stole During the Second Active Shift",
            "firstInactiveShiftScored": "Scored During First Inactive Shift",
            "firstInactiveShiftFed": "Fed to alliance side during first inactive shift",
            "firstInactiveShiftDefense": "Played defense during first inactive shift",
            "firstInactiveShiftStole": "Stole During the First Inactive Shift",
            "firstInactiveShiftIntaked": "Intaked During First Inactive Shift",
            "secondInactiveShiftScored": "Scored During Second Inactive Shift",
            "secondInactiveShiftFed": "Fed to alliance side during second inactive shift",
            "secondInactiveShiftDefense": "Played defense during second inactive shift",
            "secondInactiveShiftStole": "Stole During the Second Inactive Shift",
            "secondInactiveShiftIntaked": "Intaked During Second Inactive Shift",
            "endgameFuelTotal": "Total Endgame Fuel",
            "endgameFed": "Fed to alliance side during endgame",
            "endgameDefense": "Played defense during endgame",
            "endgameStole": "Stole During Endgame",
            "endClimb": "Endgame Climb",
            "endClimbAttempted": "Endgame Climb Attempted",
            "feedingRank":"Feeding Rank",
            "defenseRank":"Defense Rank",
            "stealRank": "Stealing Rank",
            "driverRank": "Driver Skill Rank",
            "vibeCheck": "Vibe Check",
        }
        self.matchTableDisplayNames = {
            "team": "Team",
            "displayName": "Display Name",
            "score": "Score Impact",
            "matchNumber": "Match Number",
            "setNumber": "Set Number",
            "compLevel": "Competition Level",
            "startPos": "Starting Position",
            "preloadFuel": "Preloaded Fuel",
            # "autoFuel": "Auto Fuel",
            "autoFuelTotal": "Total Auto Fuel",
            # "autoFuelTotalMissed": "Total Auto Fuel Missed",
            # "autoFuelAverageShotPerSecond": "Average Auto Fuel Shot Per Second",
            # "autoFuelAverageScoredPerSecond": "Average Auto Fuel Scored Per Second",
            "autoDepot": "Intaked from Depot During Auto",
            "autoBump": "Went over the Bump in Auto",
            "autoTrench": "Went under the Trench in Auto",
            "autoNeutralIntake": "Intaked from the Neutral Zone during Auto",
            "autoAttemptedSecondScore": "Attempted to score past preloads during Auto",
            "autoSucceededSecondScore": "Succeeded to score past preloads during Auto",
            "autoClimbAttempted": "Auto L1 Climb Attempted",
            "autoClimbSuccess": "Auto L1 Climb Succeeded",
            "autoOutpostFeed": "Fed from the Outpost during Auto",
            "autoFedToOutpost": "Fed to the Outpost during Auto",
            "firstShift": "Active in first and third shifts",
            # "transitionFuel": "Transition Shift Fuel",
            "transitionFuelTotal": "Total Transition Shift Fuel",
            "transitionFed": "Fed during transition shift",
            "transitionDefense": "Defended during transition shift",
            "transitionStole": "Stole During Transition Period",
            "firstActiveShiftFuelTotal": "Total First Active Shift Fuel",
            "firstActiveShiftFed": "Fed to alliance side during first active shift",
            "firstActiveShiftDefense": "Played defense during first active shift",
            "firstActiveShiftStole": "Stole During the First Active Shift",
            "secondActiveShiftFuelTotal": "Total Second Active Shift Fuel",
            "secondActiveShiftFed": "Fed to alliance side during second active shift",
            "secondActiveShiftDefense": "Played defense during second active shift",
            "secondActiveShiftStole": "Stole During the Second Active Shift",
            # "transitionFuelTotalMissed": "Total Transition Shift Fuel Missed",
            # "transitionFuelAverageShotPerSecond": "Average Transition Fuel Shot Per Second",
            # "transitionFuelAverageScoredPerSecond": "Average Transition Fuel Scored Per Second",
            # "firstActiveShiftFuel": "First Active Shift Fuel",
            # "firstActiveShiftFuelTotalMissed": "Total First Active Shift Fuel Missed",
            # "firstActiveShiftFuelAverageShotPerSecond": "Average First Active Shift Fuel Shot Per Second",
            # "firstActiveShiftFuelAverageScoredPerSecond": "Average First Active Shift Fuel Scored Per Second",
            # "secondActiveShiftFuel": "Second Active Shift Fuel",
            # "secondActiveShiftFuelTotalMissed": "Total Second Active Shift Fuel Missed",
            # "secondActiveShiftFuelAverageShotPerSecond": "Average Second Active Shift Fuel Shot Per Second",
            # "secondActiveShiftFuelAverageScoredPerSecond": "Average Second Active Shift Fuel Scored Per Second",
            "firstInactiveShiftScored": "Scored During First Inactive Shift",
            "firstInactiveShiftFed": "Fed to alliance side during first inactive shift",
            "firstInactiveShiftDefense": "Played defense during first inactive shift",
            "firstInactiveShiftStole": "Stole During the First Inactive Shift",
            "firstInactiveShiftIntaked": "Intaked During First Inactive Shift",
            "secondInactiveShiftScored": "Scored During Second Inactive Shift",
            "secondInactiveShiftFed": "Fed to alliance side during second inactive shift",
            "secondInactiveShiftDefense": "Played defense during second inactive shift",
            "secondInactiveShiftStole": "Stole During the Second Inactive Shift",
            "secondInactiveShiftIntaked": "Intaked During Second Inactive Shift",
            "endgameFuelTotal": "Total Endgame Fuel",
            "endgameFed": "Fed to alliance side during endgame",
            "endgameDefense": "Played defense during endgame",
            "endgameStole": "Stole During Endgame",
            # "endgameFuel": "Endgame Fuel",
            # "endgameFuelTotalMissed": "Total Endgame Fuel Missed",
            # "endgameFuelAverageShotPerSecond": "Average Endgame Fuel Shot Per Second",
            # "endgameFuelAverageScoredPerSecond": "Average Endgame Fuel Scored Per Second",
            "endClimb": "Endgame Climb",
            "endClimbAttempted": "Endgame Climb Attempted",
            # "playedDefense": "Played Defense",
            # "fedToAllianceActive": "Fed to Alliance Zone during Active Shift",
            # "fedToAllianceInactive": "Fed to Alliance Zone during Inactive Shift",
            "outpostIntake": "Intaked from the Outpost",
            "groundIntake": "Intaked from the ground",
            "totalFuel": "Total Fuel Worth Points",
            "totalTeleopFuel": "Total Teleop Fuel Worth Points",
            # "totalFuelMissed": "Total Fuel Missed",
            # "totalFuelAverageShotPerSecond": "Average Fuel Shot Per Second",
            # "totalFuelAverageScoredPerSecond": "Average Fuel Scored Per Second",
            "feedingRank":"Feeding Rank",
            "feedingComment":"Feeding Comment",
            "defenseRank":"Defense Rank",
            "defenseComment":"Defense Comment",
            "stealRank": "Stealing Rank",
            "driverRank": "Driver Skill Rank",
            "vibeCheck": "Vibe Check",
            "minorFouls": "Minor Fouls",
            "majorFouls": "Major Fouls",
            "comment": "Comment",
            "cannedComments": "Canned Comments",
            "scout": "Scout",
        }
        self.cannedComments = [
            "Good Driving",
            "Bad Driving",
            "Fast Driving",
            "Slow Driving",
            "Shoot While Intaking",
            "Played Defense",
            "Good Defense",
            "Bad Defense",
            "Was Defended",
            "Multiple Fouls",
            "Multiple Jams",
            "Bumpers Off",
            "Tipped/Stuck",
            "Died",
            "No Show",
            "Bad Descision Making",
        ]        
        self.pitScout = (
            (
                {
                    "text":"How many batteries/battery chargers do they have?",
                    "type":"text",
                    "id":"battery"
                },
            ),
            (
                {
                    "text":"Are their bumpers open or closed?",
                    "type":"select",
                    "options":(
                        ("Closed","closed"),
                        ("Open","open")
                    ),
                    "id":"bumpers"
                },
            ),
            (
                {
                    "text":"What side do they shoot out of?",
                    "type":"select",
                    "options":(
                        ("Shooting on same as intake","same"),
                        ("Shooting on opposite as intake","opposite"),
                        ("Shooting using a turret","turret")
                    ),
                    "id":"shootside"
                },
            ),
            (
                {
                    "text":"What drivebase do they use?",
                    "type":"select",
                    "options":(
                        ("Swerve","swerve","showIfChecked('drivebase-swerve','swervetype-container')"),
                        ("Tank","tank","0"),
                    ),
                    "other":True,
                    "id":"drivebase",
                    "onclick":True
                },
                {
                    "text":"What swerve do they use?",
                    "type":"text",
                    "id":"swervetype",
                    "hidden":True
                }
            ),
            (
                {
                    "text":"What programming language(s) do they use?",
                    "type":"select",
                    "options":(
                        ("Java","java"),
                        ("C++","cpp"),
                        ("Python","python"),
                        ("Labview","labview"),
                    ),
                    "other":True,
                    "id":"language"
                },
            ),
            (
                {
                    "text":"Do they CURRENTLY have a camera on their robot? If so, what for? Do they have auto aim? Do they use it for anything during auto?",
                    "type":"text",
                    "id":"camera"
                },
            ),
            (
                {
                    "text":"What autos do they have?",
                    "type":"select",
                    "options":(
                        ("Left","left","showIfChecked('has-auto-left','auto-describe-left-container','block')"),
                        ("Right","right","showIfChecked('has-auto-right','auto-describe-right-container','block')"),
                        ("Mid","mid","showIfChecked('has-auto-mid','auto-describe-mid-container','block')"),
                    ),
                    "id":"has-auto",
                    "onclick":True
                },
                {
                    "text":"What is their left auto?",
                    "type":"text",
                    "id":"auto-describe-left",
                    "hidden":True
                },
                {
                    "text":"What is their right auto?",
                    "type":"text",
                    "id":"auto-describe-right",
                    "hidden":True
                },
                {
                    "text":"What is their mid auto?",
                    "type":"text",
                    "id":"auto-describe-mid",
                    "hidden":True
                },
                {
                    "text":"What can they realistically do during auto?",
                    "type":"select",
                    "options":(
                        ("Score preloaded fuel in hub", "fuel-preload"),
                        ("Score intaked fuel", "fuel"),
                        ("Move over bump","bump"),
                        ("Move under trench","trench"),
                        ("Intake from depot", "depot"),
                        ("Intake from outpost chute", "outpost"),
                        ("Intake from neutral zone", "neutral"),
                        ("Climb level 1 in the center", "climb1-center"),
                        ("Climb level 1 on the sides", "climb1-side"),
                        ("Shoot while moving", "moving"),
                    ),
                    "id":"auto"
                },
            ),
            (
                {
                    "text":"What can they realistically do during teleop?",
                    "type":"select",
                    "options":(
                        ("Score in hub", "fuel"),
                        ("Move over bump","bump"),
                        ("Move under trench","trench"),
                        ("Intake from depot", "depot"),
                        ("Intake from outpost chute", "outpost"),
                        ("Intake from neutral zone", "neutral"),
                        ("Shoot while moving", "moving"),
                        ("Shoot with distance", "distance"),
                    ),
                    "id":"tele"
                },
            ),
            (
                {
                    "text":"Can they climb?",
                    "type":"select",
                    "options":(
                        ("No climb","none"),
                        ("Climb level 1 in the center", "1-center"),
                        ("Climb level 1 on the sides", "1-side"),
                        ("Climb level 2 in the center", "2-center"),
                        ("Climb level 2 on the sides", "2-side"),
                        ("Climb level 3 in the center", "3-center"),
                        ("Climb level 3 on the sides", "3-side"),
                    ),
                    "id":"climb"
                },
                {
                    "text":"How long does their climb usually take?",
                    "type":"text",
                    "id":"climb-time",
                    "optional":True
                },
            ),
            (
                {
                    "text":"How much fuel can they intake and hold at a time?",
                    "type":"text",
                    "id":"hold",
                },
            ),
            (
                {
                    "text":"What is their fuel per second?",
                    "type":"text",
                    "id":"rate",
                },
            ),
            (
                {
                    "text":"On offense, do they primarily rely on having individual cycles or shoot-while-moving clean up?",
                    "type":"text",
                    "id":"cycles",
                },
            ),
            (
                {
                    "text":"How many points do they usually get per game?",
                    "type":"text",
                    "id":"points",
                },
            ),
            (
                {
                    "text":"What is their estimated shooting range?",
                    "type":"text",
                    "id":"range",
                },
            ),
            (
                {
                    "text":"What is their robot weight (without batteries and bumpers)?",
                    "type":"text",
                    "id":"weight",
                },
            ),
            (
                {
                    "text":"How many motors are on their intake?",
                    "type":"text",
                    "id":"motors",
                },
            ),
            (
                {
                    "text":"How wide is their intake?",
                    "type":"text",
                    "id":"width-intake",
                },
            ),
            (
                {
                    "text":"How wide is their shooter (for drum shooters, leave blank if N/A)?",
                    "type":"text",
                    "id":"width-shooter",
                },
            ),
            (
                {
                    "text":"Anything special we should know about their robot?",
                    "type":"text",
                    "id":"special",
                    "optional":True
                },
            ),
            (
                {
                    "text":"How experienced are their drivers?",
                    "type":"text",
                    "id":"experience",
                },
            ),
            (
                {
                    "text":"Observe for yourself and don't ask a question: how organized is their pit?",
                    "type":"text",
                    "id":"organize",
                },
            ),
            (
                {
                    "text":"Any other comments?",
                    "type":"text",
                    "id":"special",
                    "optional":True
                },
            ),
        )

    def calculateScore(
        self,
        fuel: int,
        autoClimb: bool,
        endClimb: EndPositionRebuilt,
        minorFouls: int,
        majorFouls: int,
    ) -> int:
        """
        Calculate the total score from scouted values.

        Inputs:
        - Self explanatory

        Outputs:
        - int: total score, minus points from fouls

        """
        score = 0
        score += int(fuel)
        if autoClimb:
            score += 15
        match endClimb:
            case EndPositionRebuilt.L1:
                score += 10
            case EndPositionRebuilt.L2:
                score += 20
            case EndPositionRebuilt.L3:
                score += 30

        score -= 5 * int(minorFouls)
        score -= 15 * int(majorFouls)
        return score

    def scoreRobotInMatch(
        self,
        matchNumber: int,
        setNumber: int,
        compLevel: CompLevel,
        station: Station,
        startPos: float,
        preloadFuel: int,
        autoFuelTotal: int,
        autoDepot: bool,
        autoBump: bool,
        autoTrench: bool,
        autoNeutralIntake: bool,
        autoAttemptedSecondScore: bool,
        autoSucceededSecondScore: bool,
        autoClimbAttempted: bool,
        autoClimbSuccess: bool,
        autoOutpostFeed: bool,
        autoFedToOutpost: bool,
        firstShift: bool,
        transitionFuelTotal: int,
        transitionFed: bool,
        transitionDefense: bool,
        transitionStole: bool,
        firstActiveShiftFuelTotal: int,
        firstActiveShiftFed: bool,
        firstActiveShiftDefense: bool,
        firstActiveShiftStole: bool,
        secondActiveShiftFuelTotal: int,
        secondActiveShiftFed: bool,
        secondActiveShiftDefense: bool,
        secondActiveShiftStole: bool,
        firstInactiveShiftScored: bool,
        firstInactiveShiftFed: bool,
        firstInactiveShiftDefense: bool,
        firstInactiveShiftStole: bool,
        firstInactiveShiftIntaked:bool,
        secondInactiveShiftScored: bool,
        secondInactiveShiftFed: bool,
        secondInactiveShiftDefense: bool,
        secondInactiveShiftStole: bool,
        secondInactiveShiftIntaked:bool,
        endgameFuelTotal: int,
        endgameFed: bool,
        endgameDefense: bool,
        endgameStole: bool,
        endClimb: EndPositionRebuilt,
        endClimbAttempted: EndPositionRebuilt,
        # playedDefense: bool,
        # fedToAllianceActive: bool,
        # fedToAllianceInactive: bool,
        outpostIntake: bool,
        groundIntake: bool,
        fedToOutpost: bool,
        # "feedingRank":"Feeding Rank",
            # "feedingComment":"Feeding Comment",
            # "defenseRank":"Defense Rank",
            # "defenseComment":"Defense Comment",
        feedingRank: int|None,
        feedingComment: str|None,
        defenseRank:int|None,
        defenseComment:str|None,
        stealRank: int|None,
        driverRank: int,
        vibeCheck: int,
        minorFouls: int,
        majorFouls: int,
        comment: str,
        cannedComments: List[str],
        scout: str,
    ) -> bool:
        """
        Scores one robot in a match.

        Should change every year.

        Inputs:
        - self explanitory

        Returns:
        - Boolean: if the robot was successfully scored
        """
        totalFuel = (
            autoFuelTotal
            + transitionFuelTotal
            + firstActiveShiftFuelTotal
            + secondActiveShiftFuelTotal
            + endgameFuelTotal
        )

        totalTeleopFuel = (
            transitionFuelTotal
            + firstActiveShiftFuelTotal
            + secondActiveShiftFuelTotal
            + endgameFuelTotal
        )

        data = {
            "startPos": startPos,
            "preloadFuel": preloadFuel,
            # "autoFuel": autoFuel,
            "autoFuelTotal": autoFuelTotal,
            # "autoFuelTotalMissed": autoFuelTotalMissed,
            "autoDepot": autoDepot,
            "autoBump": autoBump,
            "autoTrench": autoTrench,
            "autoNeutralIntake": autoNeutralIntake,
            "autoAttemptedSecondScore": autoAttemptedSecondScore,
            "autoSucceededSecondScore": autoSucceededSecondScore,
            "autoClimbAttempted": autoClimbAttempted,
            "autoClimbSuccess": autoClimbSuccess,
            "autoOutpostFeed": autoOutpostFeed,
            "autoFedToOutpost": autoFedToOutpost,
            "firstShift": firstShift,
            # "transitionFuel": transitionFuel,
            "transitionFuelTotal": transitionFuelTotal,
            # "transitionFuelTotalMissed": transitionFuelTotalMissed,
            "transitionFed": transitionFed,
            "transitionDefense": transitionDefense,
            "transitionStole": transitionStole,
            # "firstActiveShiftFuel": firstActiveShiftFuel,
            "firstActiveShiftFuelTotal": firstActiveShiftFuelTotal,
            "firstActiveShiftFed": firstActiveShiftFed,
            "firstActiveShiftDefense": firstActiveShiftDefense,
            "firstActiveShiftStole": firstActiveShiftStole,
            # "firstActiveShiftFuelTotalMissed": firstActiveShiftFuelTotalMissed,
            # "secondActiveShiftFuel": secondActiveShiftFuel,
            "secondActiveShiftFuelTotal": secondActiveShiftFuelTotal,
            "secondActiveShiftFed": secondActiveShiftFed,
            "secondActiveShiftDefense": secondActiveShiftDefense,
            "secondActiveShiftStole": secondActiveShiftStole,
            # "secondActiveShiftFuelTotalMissed": secondActiveShiftFuelTotalMissed,
            "firstInactiveShiftScored": firstInactiveShiftScored,
            "firstInactiveShiftFed": firstInactiveShiftFed,
            "firstInactiveShiftDefense": firstInactiveShiftDefense,
            "firstInactiveShiftStole": firstInactiveShiftStole,
            "firstInactiveShiftIntaked": firstInactiveShiftIntaked,
            "secondInactiveShiftScored": secondInactiveShiftScored,
            "secondInactiveShiftFed": secondInactiveShiftFed,
            "secondInactiveShiftDefense": secondInactiveShiftDefense,
            "secondInactiveShiftStole": secondInactiveShiftStole,
            "secondInactiveShiftIntaked": secondInactiveShiftIntaked,
            # "endgameFuel": endgameFuel,
            "endgameFuelTotal": endgameFuelTotal,
            "endgameFed": endgameFed,
            "endgameDefense": endgameDefense,
            "endgameStole": endgameStole,
            # "endgameFuelTotalMissed": endgameFuelTotalMissed,
            "endClimb": endClimb.value,
            "endClimbAttempted": endClimbAttempted.value,
            # "playedDefense": playedDefense,
            # "fedToAllianceActive": fedToAllianceActive,
            # "fedToAllianceInactive": fedToAllianceInactive,
            "outpostIntake": outpostIntake,
            "groundIntake": groundIntake,
            "fedToOutpost": fedToOutpost,
            "totalTeleopFuel": totalTeleopFuel,
            "totalFuel": totalFuel,
            # "totalFuelMissed": totalFuelMissed,
            "feedingRank":feedingRank,
            "feedingComment":feedingComment,
            "defenseRank":defenseRank,
            "defenseComment":defenseComment,
            "stealRank": stealRank,
            "driverRank": driverRank,
            "vibeCheck": vibeCheck,
            "minorFouls": minorFouls,
            "majorFouls": majorFouls,
            "score": self.calculateScore(
                totalFuel, autoClimbSuccess, endClimb, minorFouls, majorFouls
            ),
            "comment": comment,
            "cannedComments": cannedComments,
            "scout": scout,
        }

        # totalShotPerSecond = 0
        # totalScoredPerSecond = 0
        # totalDataLength = 0
        # for period in (
        #     "autoFuel",
        #     "transitionFuel",
        #     "firstActiveShiftFuel",
        #     "secondActiveShiftFuel",
        #     "endgameFuel",
        # ):
        #     # periodShotPerSecond = 0
        #     periodScoredPerSecond = 0
        #     dataLength = len(data[period])
        #     for i in range(dataLength):
        #         try:
        #             data[period][i]["fuelScoredPerSecond"] = (
        #                 data[period][i]["scored"] / data[period][i]["time"]
        #             )
        #         except ZeroDivisionError:
        #             data[period][i]["fuelScoredPerSecond"] = 0
        #             app.logger.warning(f"NaN calculated for fuelScoredPerSecond {station.value} in {compLevel.value}{matchNumber}_{setNumber}")
        #         # try:
        #         #     data[period][i]["fuelShotPerSecond"] = (
        #         #         data[period][i]["scored"] + data[period][i]["missed"]
        #         #     ) / data[period][i]["time"]
        #         # except ZeroDivisionError:
        #         #     data[period][i]["fuelShotPerSecond"] = 0
        #         #     app.logger.warning(f"NaN calculated for fuelShotPerSecond {station.value} in {compLevel.value}{matchNumber}_{setNumber}")

        #         # periodShotPerSecond += data[period][i]["fuelShotPerSecond"]
        #         periodScoredPerSecond += data[period][i]["fuelScoredPerSecond"]
        #         # totalShotPerSecond += data[period][i]["fuelShotPerSecond"]
        #         totalScoredPerSecond += data[period][i]["fuelScoredPerSecond"]

        #     totalDataLength += dataLength
        #     dataLength = 1 if dataLength <= 0 else dataLength

        #     # try:
        #     #     data[f"{period}AverageShotPerSecond"] = periodShotPerSecond / dataLength
        #     # except ZeroDivisionError:
        #     #         data[f"{period}AverageShotPerSecond"] = 0
        #     #         app.logger.warning(f"NaN calculated for {period}AverageShotPerSecond {station.value} in {compLevel.value}{matchNumber}_{setNumber}")
        #     try:
        #         data[f"{period}AverageScoredPerSecond"] = periodScoredPerSecond / dataLength
        #     except ZeroDivisionError:
        #         data[f"{period}AverageScoredPerSecond"] = 0
        #         app.logger.warning(f"NaN calculated for {period}AverageScoredPerSecond {station.value} in {compLevel.value}{matchNumber}_{setNumber}")

        # try:
        #     data[f"totalFuelAverageShotPerSecond"] = totalShotPerSecond / totalDataLength
        # except ZeroDivisionError:
        #     data[f"totalFuelAverageShotPerSecond"] = 0
        #     app.logger.warning(f"NaN calculated for totalFuelAverageShotPerSecond {station.value} in {compLevel.value}{matchNumber}_{setNumber}")
        # try:
        #     data[f"totalFuelAverageScoredPerSecond"] = (
        #         totalScoredPerSecond / totalDataLength
        #     )
        # except ZeroDivisionError:
        #     data[f"totalFuelAverageScoredPerSecond"] = 0
        #     app.logger.warning(f"NaN calculated for totalFuelAverageScoredPerSecond {station.value} in {compLevel.value}{matchNumber}_{setNumber}")

        result = matches.update_many(
            {
                "matchNumber": matchNumber,
                "setNumber": setNumber,
                "compLevel": compLevel.value,
            },
            {"$push": {"results." + station.value: data}},
        )
        if result.matched_count == 0:
            app.logger.info(  # type: ignore
                f"Failed to score robot {station.value} for match {matchNumber} by {scout}: Match does not exist."
            )
            return False
        writeToCacheFile("","statMatrixCache")
        app.logger.info(f"Robot {station.value} scored for match {matchNumber} by {scout}.")  # type: ignore
        return True

    def calculateScoreFromData(
        self, matchData: dict, team: Station, edit: int = -1
    ) -> int:
        """
        Gets a robot's result from the database and scores it.

        Inputs:
        - matchData (dict): a match dict
        - team (Station): the station to score
        - edit (int): which revision to score, defaults to the latest

        Returns:
        - int: calculated score
        """
        results = matchData["results"][team.value][edit]
        if type(results["score"]) == int:
            return results["score"]
        else:
            app.logger.error(f"Request for score for {team.value} failed.")
            abort(400)

    def calculateAverageAllianceScore(
        self, team1: int, team2: int, team3: int, calc=getMeanOfScoringCategory
    ) -> dict | None:
        """
        Calculates a hypothetical alliance score of three teams using their average results in each category.

        Should be edited every year.

        Inputs:
        - team1 (int): team number 1
        - team2 (int): team number 2
        - team3 (int): team number 3
        - calc (function): the static function to use, defaults to mean

        Returns:
        - dict or none: dict of predicted results, or None if any teams are not found.
        """
        team1Listing = getTeam(team1)
        if not team1Listing:
            return None
        team2Listing = getTeam(team2)
        if not team2Listing:
            return None
        team3Listing = getTeam(team3)
        if not team3Listing:
            return None

        team1Data = getTeamResults(team1)
        team2Data = getTeamResults(team2)
        team3Data = getTeamResults(team3)

        team1AutoClimb = int(calc(team1Data, "autoClimbSuccess") >= 0.5)
        team2AutoClimb = int(calc(team2Data, "autoClimbSuccess") >= 0.5)
        team3AutoClimb = int(calc(team3Data, "autoClimbSuccess") >= 0.5)
        autoClimbTotal = team1AutoClimb + team2AutoClimb + team3AutoClimb

        team1End = round(calc(team1Data, "endClimb"))
        team2End = round(calc(team2Data, "endClimb"))
        team3End = round(calc(team3Data, "endClimb"))

        team1Minors = calc(team1Data, "minorFouls")
        team2Minors = calc(team2Data, "minorFouls")
        team3Minors = calc(team3Data, "minorFouls")

        team1Majors = calc(team1Data, "majorFouls")
        team2Majors = calc(team2Data, "majorFouls")
        team3Majors = calc(team3Data, "majorFouls")

        team1Fuel = round(calc(team1Data, "totalFuel"))
        team2Fuel = round(calc(team2Data, "totalFuel"))
        team3Fuel = round(calc(team3Data, "totalFuel"))

        fuel = team1Fuel + team2Fuel + team3Fuel

        score = self.calculateScore(fuel, False, EndPositionRebuilt.NONE, 0, 0)

        score += autoClimbTotal * 15
        score += (
            10
            if team1End == EndPositionRebuilt.L1.value
            else (
                20
                if team1End == EndPositionRebuilt.L2.value
                else 30 if team1End == EndPositionRebuilt.L3.value else 0
            )
        )
        score += (
            10
            if team2End == EndPositionRebuilt.L1.value
            else (
                20
                if team2End == EndPositionRebuilt.L2.value
                else 30 if team2End == EndPositionRebuilt.L3.value else 0
            )
        )
        score += (
            10
            if team3End == EndPositionRebuilt.L1.value
            else (
                20
                if team3End == EndPositionRebuilt.L2.value
                else 30 if team3End == EndPositionRebuilt.L3.value else 0
            )
        )

        return {
            "score": score,
            "autoClimb": autoClimbTotal,
            "team1AutoClimb": team1AutoClimb,
            "team2AutoClimb": team2AutoClimb,
            "team3AutoClimb": team3AutoClimb,
            "team1Fuel": team1Fuel,
            "team2Fuel": team2Fuel,
            "team3Fuel": team3Fuel,
            "fuelTotal": fuel,
            "endPos1": team1End,
            "endPos2": team2End,
            "endPos3": team3End,
            "minorFouls": team1Minors + team2Minors + team3Minors,
            "majorFouls": team1Majors + team2Majors + team3Majors,
        }

    def calculateMinMaxAllianceScore(
        self, team1: int, team2: int, team3: int, maximum: bool = True
    ) -> dict | None:
        """
        Calculates a hypothetical alliance score of three teams using their minimum or maximum results in each category.

        Inputs:
        - team1 (int): team number 1
        - team2 (int): team number 2
        - team3 (int): team number 3
        - maximum (bool): True uses maximum, False uses minimum, defaults to True

        Returns:
        - dict or none: dict of predicted results, or None if any teams are not found.
        """
        statistic = getMatchWithHighestValue if maximum else getMatchWithLowestValue
        oppositeStatistic = (
            getMatchWithLowestValue if maximum else getMatchWithHighestValue
        )

        team1Listing = getTeam(team1)
        if not team1Listing:
            return None
        team2Listing = getTeam(team2)
        if not team2Listing:
            return None
        team3Listing = getTeam(team3)
        if not team3Listing:
            return None

        team1Data = getTeamResults(team1)
        team2Data = getTeamResults(team2)
        team3Data = getTeamResults(team3)

        team1AutoClimb = int(statistic(team1Data, "autoClimb")["value"] >= 0.5)
        team2AutoClimb = int(statistic(team2Data, "autoClimb")["value"] >= 0.5)
        team3AutoClimb = int(statistic(team3Data, "autoClimb")["value"] >= 0.5)
        autoClimbTotal = team1AutoClimb + team2AutoClimb + team3AutoClimb

        team1End = round(statistic(team1Data, "endPos")["value"])
        team2End = round(statistic(team2Data, "endPos")["value"])
        team3End = round(statistic(team3Data, "endPos")["value"])

        team1Minors = statistic(team1Data, "minorFouls")["value"]
        team2Minors = statistic(team2Data, "minorFouls")["value"]
        team3Minors = statistic(team3Data, "minorFouls")["value"]

        team1Majors = statistic(team1Data, "majorFouls")["value"]
        team2Majors = statistic(team2Data, "majorFouls")["value"]
        team3Majors = statistic(team3Data, "majorFouls")["value"]

        fuel = (
            round(statistic(team1Data, "totalFuel")["value"])
            + round(statistic(team2Data, "totalFuel")["value"])
            + round(statistic(team3Data, "totalFuel")["value"])
        )

        score = self.calculateScore(fuel, False, EndPositionRebuilt.NONE, 0, 0)

        score += autoClimbTotal * 15
        score += (
            10
            if team1End == EndPositionRebuilt.L1.value
            else (
                20
                if team1End == EndPositionRebuilt.L2.value
                else 30 if team1End == EndPositionRebuilt.L3.value else 0
            )
        )
        score += (
            10
            if team2End == EndPositionRebuilt.L1.value
            else (
                20
                if team2End == EndPositionRebuilt.L2.value
                else 30 if team2End == EndPositionRebuilt.L3.value else 0
            )
        )
        score += (
            10
            if team3End == EndPositionRebuilt.L1.value
            else (
                20
                if team3End == EndPositionRebuilt.L2.value
                else 30 if team3End == EndPositionRebuilt.L3.value else 0
            )
        )

        return {
            "score": score,
            "autoClimb": autoClimbTotal,
            "fuelTotal": fuel,
            "endPos1": team1End,
            "endPos2": team2End,
            "endPos3": team3End,
            "minorFouls": team1Minors + team2Minors + team3Minors,
            "majorFouls": team1Majors + team2Majors + team3Majors,
        }

    def getAllStats(self, team: int) -> dict:
        """
        Calculates all stats for every single scoring category.

        Inputs:
        - team (int): Team number

        Returns:
        - dict: dict of every scoring category with every stat
        """
        teamResults = getTeamResults(team)
        return {
            "score": getAllStatsForCategory(teamResults, "score"),
            "preloadFuel": getAllStatsForCategory(teamResults, "preloadFuel"),
            "autoFuelTotal": getAllStatsForCategory(teamResults, "autoFuelTotal"),
            # "autoFuelTotalMissed": getAllStatsForCategory(
            #     teamResults, "autoFuelTotalMissed"
            # ),
            # "autoFuelAverageShotPerSecond": getAllStatsForCategory(
            #     teamResults, "autoFuelAverageShotPerSecond"
            # ),
            # "autoFuelAverageScoredPerSecond": getAllStatsForCategory(
            #     teamResults, "autoFuelAverageScoredPerSecond"
            # ),
            "autoClimbAttempted": getAllStatsForCategory(
                teamResults, "autoClimbAttempted"
            ),
            "firstShift": getAllStatsForCategory(teamResults, "firstShift"),
            "transitionFuelTotal": getAllStatsForCategory(
                teamResults, "transitionFuelTotal"
            ),
            # "transitionFuelTotalMissed": getAllStatsForCategory(
            #     teamResults, "transitionFuelTotalMissed"
            # ),
            # "transitionFuelAverageShotPerSecond": getAllStatsForCategory(
            #     teamResults, "transitionFuelAverageShotPerSecond"
            # ),
            # "transitionFuelAverageScoredPerSecond": getAllStatsForCategory(
            #     teamResults, "transitionFuelAverageScoredPerSecond"
            # ),
            "firstActiveShiftFuelTotal": getAllStatsForCategory(
                teamResults, "firstActiveShiftFuelTotal"
            ),
            # "firstActiveShiftFuelTotalMissed": getAllStatsForCategory(
            #     teamResults, "firstActiveShiftFuelTotalMissed"
            # ),
            # "firstActiveShiftFuelAverageShotPerSecond": getAllStatsForCategory(
            #     teamResults, "firstActiveShiftFuelAverageShotPerSecond"
            # ),
            # "firstActiveShiftFuelAverageScoredPerSecond": getAllStatsForCategory(
            #     teamResults, "firstActiveShiftFuelAverageScoredPerSecond"
            # ),
            "secondActiveShiftFuelTotal": getAllStatsForCategory(
                teamResults, "secondActiveShiftFuelTotal"
            ),
            # "secondActiveShiftFuelTotalMissed": getAllStatsForCategory(
            #     teamResults, "secondActiveShiftFuelTotalMissed"
            # ),
            # "secondActiveShiftFuelAverageShotPerSecond": getAllStatsForCategory(
            #     teamResults, "secondActiveShiftFuelAverageShotPerSecond"
            # ),
            # "secondActiveShiftFuelAverageScoredPerSecond": getAllStatsForCategory(
            #     teamResults, "secondActiveShiftFuelAverageScoredPerSecond"
            # ),
            "endgameFuelTotal": getAllStatsForCategory(teamResults, "endgameFuelTotal"),
            # "endgameFuelTotalMissed": getAllStatsForCategory(
            #     teamResults, "endgameFuelTotalMissed"
            # ),
            # "endgameFuelAverageShotPerSecond": getAllStatsForCategory(
            #     teamResults, "endgameFuelAverageShotPerSecond"
            # ),
            # "endgameFuelAverageScoredPerSecond": getAllStatsForCategory(
            #     teamResults, "endgameFuelAverageScoredPerSecond"
            # ),
            "endClimb": getAllStatsForCategory(teamResults, "endClimb"),
            "endClimbAttempted": getAllStatsForCategory(teamResults, "endClimbAttempted"),
            "totalFuel": getAllStatsForCategory(teamResults, "totalFuel"),
            "totalTeleopFuel": getAllStatsForCategory(teamResults,"totalTeleopFuel"),
            # "totalFuelAverageShotPerSecond": getAllStatsForCategory(
            #     teamResults, "totalFuelAverageShotPerSecond"
            # ),
            # "totalFuelAverageScoredPerSecond": getAllStatsForCategory(
            #     teamResults, "totalFuelAverageScoredPerSecond"
            # ),
            "defenseRank": getAllStatsForCategory(teamResults,"defenseRank"),
            "feedingRank": getAllStatsForCategory(teamResults,"feedingRank"),
            "stealRank": getAllStatsForCategory(teamResults,"stealRank"),
            "driverRank": getAllStatsForCategory(teamResults,"driverRank"),
            "vibeCheck": getAllStatsForCategory(teamResults,"vibeCheck"),
            "minorFouls": getAllStatsForCategory(teamResults, "minorFouls"),
            "majorFouls": getAllStatsForCategory(teamResults, "majorFouls"),
        }

    def calculateAllianceFromMatches(
        self,
        team1: int,
        match1: list,
        team2: int,
        match2: list,
        team3: int,
        match3: list,
        jsonSerializable: bool = False,
    ) -> dict:
        """
        Adds together results for three teams from given match data to predict their performance as an alliance.

        Inputs:
        - team1 (int): team 1 number
        - match1 (list): match data for team 1
        - team2 (int): team 2 number
        - match2 (list): match data for team 2
        - team3 (int): team 3 number
        - match3 (list): match data for team 3
        - jsonSerializable (bool): if True, converts EndPositionRebuilt objects in endgameClimbs to int. defaults to False.

        Returns:
        - dict: predicted results dict
        """
        team1Station = None
        for station, team in match1[0]["teams"].items():
            if team == team1:
                team1Station = Station(station)
        if not team1Station:
            return {}
        team2Station = None
        for station, team in match2[0]["teams"].items():
            if team == team2:
                team2Station = Station(station)
        if not team2Station:
            return {}
        team3Station = None
        for station, team in match3[0]["teams"].items():
            if team == team3:
                team3Station = Station(station)
        if not team3Station:
            return {}

        team1Results = match1[0]["results"][team1Station.value]
        team2Results = match2[0]["results"][team2Station.value]
        team3Results = match3[0]["results"][team3Station.value]

        autoFuelTotal = (
            team1Results[-1]["autoFuelTotal"]
            + team2Results[-1]["autoFuelTotal"]
            + team3Results[-1]["autoFuelTotal"]
        )
        # autoFuelTotalMissed = (
        #     team1Results[-1]["autoFuelTotalMissed"]
        #     + team2Results[-1]["autoFuelTotalMissed"]
        #     + team3Results[-1]["autoFuelTotalMissed"]
        # )

        transitionFuelTotal = (
            team1Results[-1]["transitionFuelTotal"]
            + team2Results[-1]["transitionFuelTotal"]
            + team3Results[-1]["transitionFuelTotal"]
        )
        # transitionFuelTotalMissed = (
        #     team1Results[-1]["transitionFuelTotalMissed"]
        #     + team2Results[-1]["transitionFuelTotalMissed"]
        #     + team3Results[-1]["transitionFuelTotalMissed"]
        # )

        firstActiveShiftFuelTotal = (
            team1Results[-1]["firstActiveShiftFuelTotal"]
            + team2Results[-1]["firstActiveShiftFuelTotal"]
            + team3Results[-1]["firstActiveShiftFuelTotal"]
        )
        # firstActiveShiftFuelTotalMissed = (
        #     team1Results[-1]["firstActiveShiftFuelTotalMissed"]
        #     + team2Results[-1]["firstActiveShiftFuelTotalMissed"]
        #     + team3Results[-1]["firstActiveShiftFuelTotalMissed"]
        # )

        secondActiveShiftFuelTotal = (
            team1Results[-1]["secondActiveShiftFuelTotal"]
            + team2Results[-1]["secondActiveShiftFuelTotal"]
            + team3Results[-1]["secondActiveShiftFuelTotal"]
        )
        # secondActiveShiftFuelTotalMissed = (
        #     team1Results[-1]["secondActiveShiftFuelTotalMissed"]
        #     + team2Results[-1]["secondActiveShiftFuelTotalMissed"]
        #     + team3Results[-1]["secondActiveShiftFuelTotalMissed"]
        # )

        endgameFuelTotal = (
            team1Results[-1]["endgameFuelTotal"]
            + team2Results[-1]["endgameFuelTotal"]
            + team3Results[-1]["endgameFuelTotal"]
        )
        # endgameFuelTotalMissed = (
        #     team1Results[-1]["endgameFuelTotalMissed"]
        #     + team2Results[-1]["endgameFuelTotalMissed"]
        #     + team3Results[-1]["endgameFuelTotalMissed"]
        # )

        endgameClimbs = [
            EndPositionRebuilt(team1Results[-1]["endClimb"]),
            EndPositionRebuilt(team2Results[-1]["endClimb"]),
            EndPositionRebuilt(team3Results[-1]["endClimb"]),
        ]

        autoClimbs = [
            team1Results[-1]["autoClimbSuccess"],
            team2Results[-1]["autoClimbSuccess"],
            team3Results[-1]["autoClimbSuccess"],
        ]

        minorFouls = (
            team1Results[-1]["minorFouls"]
            + team2Results[-1]["minorFouls"]
            + team3Results[-1]["minorFouls"]
        )
        majorFouls = (
            team1Results[-1]["majorFouls"]
            + team2Results[-1]["majorFouls"]
            + team3Results[-1]["majorFouls"]
        )

        totalFuel = (
            autoFuelTotal
            + transitionFuelTotal
            + firstActiveShiftFuelTotal
            + secondActiveShiftFuelTotal
            + endgameFuelTotal
        )

        score = self.calculateScore(
            totalFuel, False, EndPositionRebuilt.NONE, minorFouls, majorFouls
        )

        for climb in autoClimbs:
            score += 15 if climb else 0

        for climb in endgameClimbs:
            score += (
                30
                if (climb == EndPositionRebuilt.L3)
                else (
                    20
                    if (climb == EndPositionRebuilt.L2)
                    else 10 if (climb == EndPositionRebuilt.L1) else 0
                )
            )

        if jsonSerializable:
            for i in range(len(endgameClimbs)):
                endgameClimbs[i] = endgameClimbs[i].value  # type: ignore

        return {
            "autoFuelTotal": autoFuelTotal,
            # "autoFuelTotalMissed": autoFuelTotalMissed,
            "transitionFuelTotal": transitionFuelTotal,
            # "transitionFuelTotalMissed": transitionFuelTotalMissed,
            "firstActiveShiftFuelTotal": firstActiveShiftFuelTotal,
            # "firstActiveShiftFuelTotalMissed": firstActiveShiftFuelTotalMissed,
            "secondActiveShiftFuelTotal": secondActiveShiftFuelTotal,
            # "secondActiveShiftFuelTotalMissed": secondActiveShiftFuelTotalMissed,
            "endgameFuelTotal": endgameFuelTotal,
            # "endgameFuelTotalMissed": endgameFuelTotalMissed,
            "endgameClimbs": endgameClimbs,
            "autoClimbs": autoClimbs,
            "minorFouls": minorFouls,
            "majorFouls": majorFouls,
            "totalFuel": totalFuel,
            "score": score,
        }
    
    def getMaximumsForStatMatrix(self, teamDataList = None, teamResultsDict = None) -> dict[str,float]:
        if teamDataList == None:
            teamDataList = getAllTeams()
        teamNumberList = [i["number"] for i in teamDataList]

        offenseMax = 0.0000001
        defenseMax = 0.0000001
        driverMax = 0.0000001
        passingMax = 0.0000001
        stealingMax = 0.0000001
        autosMax = 0.0000001
        for teamNumber in teamNumberList:
            if teamResultsDict == None:
                tempMatchResultList = getTeamResults(teamNumber)
            else:
                tempMatchResultList = teamResultsDict[teamNumber]
            offenseScore = getMeanOfScoringCategory(tempMatchResultList,"totalTeleopFuel")
            defenseScore = getMeanOfScoringCategory(tempMatchResultList,"defenseRank")
            driverScore = getMeanOfScoringCategory(tempMatchResultList,"driverRank")
            passingScore = getMeanOfScoringCategory(tempMatchResultList,"feedingRank")
            stealingScore = getMeanOfScoringCategory(tempMatchResultList,"stealRank")
            autosScore = getMeanOfScoringCategory(tempMatchResultList,"autoFuelTotal")

            offenseMax = offenseScore if offenseScore > offenseMax else offenseMax
            defenseMax = defenseScore if defenseScore > defenseMax else defenseMax
            driverMax = driverScore if driverScore > driverMax else driverMax
            passingMax = passingScore if passingScore > passingMax else passingMax
            stealingMax = stealingScore if stealingScore > stealingMax else stealingMax
            autosMax = autosScore if autosScore > autosMax else autosMax
        return {
            "offense":offenseMax,
            "defense":defenseMax,
            "driver":driverMax,
            "passing":passingMax,
            "stealing":stealingMax,
            "autos":autosMax,
        }

    def calculateStatMatrix(self, team:int, maximums:dict|None = None, teamMatchResultList:list[dict]|None = None) -> dict[str,float]:
        """
        Calculates a team's stat matrix, with each field from a range from 0 to 1.
        1 represents the highest value for that field.
        
        Inputs:
        - team (int): team number
        - maximums (dict): results of getMaximumsForStatMatrix()

        Returns:
        - dict: stat dict
        """

        teamMatchResultList = getTeamResults(team)

        if maximums == None:
            maximums = self.getMaximumsForStatMatrix()
        
        offenseScore = getMeanOfScoringCategory(teamMatchResultList,"totalTeleopFuel")
        defenseScore = getMeanOfScoringCategory(teamMatchResultList,"defenseRank")
        driverScore = getMeanOfScoringCategory(teamMatchResultList,"driverRank")
        passingScore = getMeanOfScoringCategory(teamMatchResultList,"feedingRank")
        stealingScore = getMeanOfScoringCategory(teamMatchResultList,"stealRank")
        autosScore = getMeanOfScoringCategory(teamMatchResultList,"autoFuelTotal")

        data = {
            "offense": offenseScore/maximums["offense"],
            "defense": defenseScore/maximums["defense"],
            "driver": driverScore/maximums["driver"],
            "passing": passingScore/maximums["passing"],
            "stealing": stealingScore/maximums["stealing"],
            "autos": autosScore/maximums["autos"],
        }
        return data
    
    def calculateStatMatrices(self) -> dict[int,dict[str,float]]:
        app.logger.info(f"Initiating stat matrices: {time.time()}")
        cacheData = loadFromCacheFile("statMatrixCache")
        if cacheData:
            result = ast.literal_eval(cacheData)
            app.logger.info(f"Read from cache: {time.time()}")
        else:
            allTeamData = getAllTeams()
            allTeamResults = getAllTeamsResults(allTeamData)
            maximums = self.getMaximumsForStatMatrix(allTeamData,allTeamResults)
            

            result = {}
            app.logger.info(f"Starting to generate stat matrix calculations: {time.time()}")
            for team in allTeamData:
                teamNumber = team["number"]
                matrix = self.calculateStatMatrix(teamNumber,maximums,allTeamResults[teamNumber])
                result[teamNumber] = matrix
            writeToCacheFile(str(result),"statMatrixCache")
            app.logger.info(f"Finished calculating stat matrices: {time.time()}")
        return result