import json

import selenium
from selenium import webdriver
from selenium.common import exceptions
from selenium.webdriver.common.keys import Keys


class SaltBot():
    def __init__(self):
        self.data = {}

    def watch(self, browser, source="data.json", output="data.json", matches=1):
        """
        Watch matches, make predictions, and record the results.
        :type browser: selenium.webDriver, Example: selenium.webdriver.Chrome(). 
        :type source: str, directory to source file.
        :type target: str, directory to output file.
        :type matches: int, No. matches to watch.
        """
        if type(browser) != selenium.webdriver.chrome.webdriver.WebDriver:
            raise TypeError(
                "type(browser) != selenium.webdriver.chrome.webdriver.WebDriver, type(browser) == {}".format(type(browser)))
        if type(source) != str:
            raise TypeError(
                "type(source) != str, type(source) == {}".format(type(source)))
        if type(output) != str:
            raise TypeError(
                "type(output) != str, type(output) == {}".format(type(output)))
        if type(matches) != int:
            raise TypeError(
                "type(matches) != int, type(matches) == {}".format(type(matches)))
        if matches <= 0:
            raise ValueError(
                "matches <= 0, matches == {}, matches must be > 0".format(matches))

        # Load data from source:
        self.load_data(source)

        # Navigate to SaltyBet.com using the browser.
        url_address = "https://www.saltybet.com/"
        browser.get(url_address)

        print("Salt Bot is now watching {} matches.\n".format(matches))

        # Handle operations performed in the while loop:
        bet_status = ""  # Handle control flow.
        recorded = False  # Decide when to record the result of matches.
        red = ""  # Fighter.
        blue = ""  # Fighter.

        match = 0
        print("{}/{} matches watched.".format(match, matches))
        while match <= matches:
            try:
                # Get bet status:
                current_bet_status = browser.find_element_by_id(
                    "betstatus").text
                if len(current_bet_status) == 0:
                    continue
                elif bet_status == "":
                    bet_status = current_bet_status
                elif bet_status != current_bet_status:
                    bet_status = current_bet_status
            except exceptions.StaleElementReferenceException:
                pass
            except Exception:
                pass

            try:
                # Get fighter names:
                red_current = browser.find_element_by_id(
                    "sbettors1").find_element_by_tag_name("strong").text
                blue_current = browser.find_element_by_id(
                    "sbettors2").find_element_by_tag_name("strong").text
                # Calculate probability for fighters:
                if len(red_current) == 0 or len(blue_current) == 0:
                    continue
                elif red == "" or blue == "":
                    red = self.extract_name(red_current)
                    blue = self.extract_name(blue_current)
                    self.display(red, blue)
                elif red != red_current or blue != blue_current:
                    red = self.extract_name(red_current)
                    blue = self.extract_name(blue_current)
                    self.display(red, blue)
            except exceptions.StaleElementReferenceException:
                pass
            except Exception:
                pass

            # Record the results of a match.
            try:
                if "win" in bet_status:
                    if recorded is False:
                        if red in bet_status:
                            s = "Winner: {}, Loser: {}\n".format(red, blue)
                            print(s)
                            self.save_data("data.json", red, blue)
                            self.log_data(s)
                        elif blue in bet_status:
                            s = "Winner: {}, Loser: {}\n".format(blue, red)
                            print(s)
                            self.save_data("data.json", blue, red)
                            self.log_data(s)
                        recorded = True
                        match += 1
                        print(
                            "{}/{} matches watched.".format(match, matches))
                else:
                    recorded = False
            except exceptions.StaleElementReferenceException:
                pass
            except Exception:
                pass

    def get_probability(self, red, blue):
        """
        Calculate the probability of red and blue winning the match using the Elo Rating System.
        :type red: str, name of fighter. 
        :type blue: str, name of fighter.
        :rtype: tuple, respective probability of red and blue winning the match.
        TODO: Account for win:loss ratio of red's opponents against blue vice versa.
        """
        # Validate input:
        if type(red) != str:
            raise TypeError("type(red) != str")
        if type(blue) != str:
            raise TypeError("type(blue) != str")

        # Insufficient data return (0.5, 0.5)
        if red not in self.data or blue not in self.data:
            return (0.5, 0.5)
        else:
            # Compute the sum of matches won by both fighters:
            red_rating = sum([self.data[red][loser]
                            for loser in self.data[red]])
            blue_rating = sum([self.data[blue][loser]
                            for loser in self.data[blue]])

            # Decremenet fighter rating by their total losses against the other fighter:
            if red in self.data[blue]:
                red_rating -= self.data[blue][red]
            if blue in self.data[red]:
                blue_rating -= self.data[red][blue]

            # Transform fighter rating:
            red_rating = pow(10, max(0, red_rating) / 400)
            blue_rating = pow(10, max(0, blue_rating) / 400)

            # Calculate red and blue's probability of winning:
            red_probability = red_rating / (red_rating + blue_rating)
            blue_probability = blue_rating / (red_rating + blue_rating)

            return (red_probability, blue_probability)

    def save_data(self, file_path, winner, loser):
        """
        Open the target file and update the winner and loser data. 
        :type file_path: str, directory path to target file.
        :type winner: str, name of fighter.
        :type loser: str, name of fighter.
        """
        # Validate input:
        if type(file_path) != str:
            raise TypeError("type(file_path) != str")
        if type(winner) != str:
            raise TypeError("type(winner) != str")
        if type(loser) != str:
            raise TypeError("type(loser) != str")

        # Open the target file and write the results.
        with open(file=file_path, mode="w+") as f:
            # Add winner and loser if they don't exist in self.data:
            self.data.setdefault(winner, {})
            self.data.setdefault(loser, {})
            self.data[winner].setdefault(loser, 0)
            self.data[loser].setdefault(winner, 0)
            # Increment the number of wins winner has against the loser:
            self.data[winner][loser] += 1
            f.write(json.dumps(self.data))

    def load_data(self, file_path):
        """
        Open the target file and load its contents as JSON.
        :type file_path: str, directory path to target file.
        :rtype: None
        """
        # Validate input:
        if type(file_path) != str:
            raise TypeError("type(file_path) != str")
        # Open the target file and load contents as json.
        with open(file=file_path, mode="r+") as f:
            data = json.load(f)
            self.data = data

    def log_data(self, data):
        file_path = "data.txt"
        with open(file=file_path, mode="a+") as f:
            f.write(data)

    def extract_name(self, raw_name):
        return str(raw_name).strip(" ")

    def display(self, red, blue):
        s = "\n{} vs. {}\n{}".format(
            red, blue, self.get_probability(red, blue))
        print(s)


def main():
    sb = SaltBot()
    sb.watch(browser=webdriver.Chrome(), source="data.json",
            output="data.json", matches=100)


if __name__ == '__main__':
    main()

import json

import selenium
from selenium import webdriver
from selenium.common import exceptions
from selenium.webdriver.common.keys import Keys


class SaltBot():
    def __init__(self):
        self.data = {}

    def watch(self, browser, source="data.json", output="data.json", matches=1):
        """
        Watch matches, make predictions, and record the results.
        :type browser: selenium.webDriver, Example: selenium.webdriver.Chrome(). 
        :type source: str, directory to source file.
        :type target: str, directory to output file.
        :type matches: int, No. matches to watch.
        """
        if type(browser) != selenium.webdriver.chrome.webdriver.WebDriver:
            raise TypeError(
                "type(browser) != selenium.webdriver.chrome.webdriver.WebDriver, type(browser) == {}".format(type(browser)))
        if type(source) != str:
            raise TypeError(
                "type(source) != str, type(source) == {}".format(type(source)))
        if type(output) != str:
            raise TypeError(
                "type(output) != str, type(output) == {}".format(type(output)))
        if type(matches) != int:
            raise TypeError(
                "type(matches) != int, type(matches) == {}".format(type(matches)))
        if matches <= 0:
            raise ValueError(
                "matches <= 0, matches == {}, matches must be > 0".format(matches))

        # Load data from source:
        self.load_data(source)

        # Navigate to SaltyBet.com using the browser.
        url_address = "https://www.saltybet.com/"
        browser.get(url_address)

        print("Salt Bot is now watching {} matches.\n".format(matches))

        # Handle operations performed in the while loop:
        bet_status = ""  # Handle control flow.
        recorded = False  # Decide when to record the result of matches.
        red = ""  # Fighter.
        blue = ""  # Fighter.

        match = 0
        print("{}/{} matches watched.".format(match, matches))
        while match <= matches:
            try:
                # Get bet status:
                current_bet_status = browser.find_element_by_id(
                    "betstatus").text
                if len(current_bet_status) == 0:
                    continue
                elif bet_status == "":
                    bet_status = current_bet_status
                elif bet_status != current_bet_status:
                    bet_status = current_bet_status
            except exceptions.StaleElementReferenceException:
                pass
            except Exception:
                pass

            try:
                # Get fighter names:
                red_current = browser.find_element_by_id(
                    "sbettors1").find_element_by_tag_name("strong").text
                blue_current = browser.find_element_by_id(
                    "sbettors2").find_element_by_tag_name("strong").text
                # Calculate probability for fighters:
                if len(red_current) == 0 or len(blue_current) == 0:
                    continue
                elif red == "" or blue == "":
                    red = self.extract_name(red_current)
                    blue = self.extract_name(blue_current)
                    self.display(red, blue)
                elif red != red_current or blue != blue_current:
                    red = self.extract_name(red_current)
                    blue = self.extract_name(blue_current)
                    self.display(red, blue)
            except exceptions.StaleElementReferenceException:
                pass
            except Exception:
                pass

            # Record the results of a match.
            try:
                if "win" in bet_status:
                    if recorded is False:
                        if red in bet_status:
                            s = "Winner: {}, Loser: {}\n".format(red, blue)
                            print(s)
                            self.save_data("data.json", red, blue)
                            self.log_data(s)
                        elif blue in bet_status:
                            s = "Winner: {}, Loser: {}\n".format(blue, red)
                            print(s)
                            self.save_data("data.json", blue, red)
                            self.log_data(s)
                        recorded = True
                        match += 1
                        print(
                            "{}/{} matches watched.".format(match, matches))
                else:
                    recorded = False
            except exceptions.StaleElementReferenceException:
                pass
            except Exception:
                pass

    def get_probability(self, red, blue):
        """
        Calculate the probability of red and blue winning the match using the Elo Rating System.
        :type red: str, name of fighter. 
        :type blue: str, name of fighter.
        :rtype: tuple, respective probability of red and blue winning the match.
        TODO: Account for win:loss ratio of red's opponents against blue vice versa.
        """
        # Validate input:
        if type(red) != str:
            raise TypeError("type(red) != str")
        if type(blue) != str:
            raise TypeError("type(blue) != str")

        # Insufficient data return (0.5, 0.5)
        if red not in self.data or blue not in self.data:
            return (0.5, 0.5)
        else:
            # Compute the sum of matches won by both fighters:
            red_rating = sum([self.data[red][loser]
                            for loser in self.data[red]])
            blue_rating = sum([self.data[blue][loser]
                            for loser in self.data[blue]])

            # Decremenet fighter rating by their total losses against the other fighter:
            if red in self.data[blue]:
                red_rating -= self.data[blue][red]
            if blue in self.data[red]:
                blue_rating -= self.data[red][blue]

            # Transform fighter rating:
            red_rating = pow(10, max(0, red_rating) / 400)
            blue_rating = pow(10, max(0, blue_rating) / 400)

            # Calculate red and blue's probability of winning:
            red_probability = red_rating / (red_rating + blue_rating)
            blue_probability = blue_rating / (red_rating + blue_rating)

            return (red_probability, blue_probability)

    def save_data(self, file_path, winner, loser):
        """
        Open the target file and update the winner and loser data. 
        :type file_path: str, directory path to target file.
        :type winner: str, name of fighter.
        :type loser: str, name of fighter.
        """
        # Validate input:
        if type(file_path) != str:
            raise TypeError("type(file_path) != str")
        if type(winner) != str:
            raise TypeError("type(winner) != str")
        if type(loser) != str:
            raise TypeError("type(loser) != str")

        # Open the target file and write the results.
        with open(file=file_path, mode="w+") as f:
            # Add winner and loser if they don't exist in self.data:
            self.data.setdefault(winner, {})
            self.data.setdefault(loser, {})
            self.data[winner].setdefault(loser, 0)
            self.data[loser].setdefault(winner, 0)
            # Increment the number of wins winner has against the loser:
            self.data[winner][loser] += 1
            f.write(json.dumps(self.data))

    def load_data(self, file_path):
        """
        Open the target file and load its contents as JSON.
        :type file_path: str, directory path to target file.
        :rtype: None
        """
        # Validate input:
        if type(file_path) != str:
            raise TypeError("type(file_path) != str")
        # Open the target file and load contents as json.
        with open(file=file_path, mode="r+") as f:
            data = json.load(f)
            self.data = data

    def log_data(self, data):
        file_path = "data.txt"
        with open(file=file_path, mode="a+") as f:
            f.write(data)

    def extract_name(self, raw_name):
        return str(raw_name).strip(" ")

    def display(self, red, blue):
        s = "\n{} vs. {}\n{}".format(
            red, blue, self.get_probability(red, blue))
        print(s)


def main():
    sb = SaltBot()
    sb.watch(browser=webdriver.Chrome(), source="data.json",
            output="data.json", matches=100)


if __name__ == '__main__':
    main()