#Most normal chat commands like /timeout, /ban, /clear are sent with periods
#in place of the forward slash. For example, to ban the user "xangold", you
#would send ".ban xangold" to the server (minus the quotes).

"""
subscribers - tier 1 1000, tier 2 2500 tier 3 5000 / semaine
DONE !gamble X : d100 50 -> x/2 gagnés
!versus
!contest
DONE !makeitrain
DONE !doubletrouble
DONE !kekettes pour voir les kekettes
cheer = 1000 points par 100 bits
!addquote
!quotelist
cooldown sur les commandes
 DONE check pour pas dépasser 100 messages/15 minutes
 DONE methode pour print sur le chat p(pour la lisibilité et la convenience)

pseudo 1: !vs "pseudo2" "montant"
bot: pseudo2 vous êtes challengé par "pseudo1"
pseudo2: !vs pseudo1 "montant"
plus on parie plus on a de chances de gagner base montant1=montant2 : 50/50
montant1/(montant1+2)*100 %
"""

"""
Erreurs : List index is out of range sur les JOIN
<class 'requests.exceptions.HTTPError'> : 400 Client Error: Bad Request for url: https://api.twitch.tv/kraken/users?login=: JOIN, problème d'API ?
le bot ne distribue plus de kekettes
!makeitrain : action quand même accomplie même si pas assez de points
subscribers : problème d'authentification

erreur ?? JOIN ??
    <class 'ValueError'> : invalid literal for int() with base 10:
    "{'display_name': 'I', 'id': '51474635', 'name': 'i', 'type': 'user', 'bio': None, 'created_at': datetime.datetime(2013, 11, 13, 16, 2, 49, 71386), 'updated_at': datetime.datetime(2017, 5, 24, 18, 0,
"""

BOT_SECRET = 'xxx'
BOT_OAUTH = 'oauth:xxx'
TARGET_OAUTH = 'xxx'
BOT_CLIENT_ID = 'xxx'

#########IMPORTS#########
import socket
import twitch #Not in standard libraries
from twitch import TwitchClient #Not in standard libraries
from twitch.api.streams import Streams #Not in standard libraries
import csv
import datetime
import time
from threading import Thread, RLock
import random as rd
import math

#########DEFINES##########
lock = RLock()

BOT_HAS_STARTED = "KekettesBot est désormais lancé !"
NOT_ENOUGH_POINTS = "{} n'a pas assez de kekettes pour cette action."
DISPLAY_POINTS = "{} a {} kekettes."
USER_CHALLENGED_YOU = "{0}, {1} t'as défié ! !versus {1} *montant* pour accepter, !versus deny pour refuser."
DISPLAY_CHALLENGE_ODDS = "{0} has put {1} on the table. {2} has put {3} on the table. {0} has {4}% chances of winning !"
VS_WIN = "You won your duel versus {0}, you win {} kekettes."
VS_LOST = "You lost your duel versus {0}, you lose {} kekettes."
GAMBLE_WON = "{} a tiré {} et a gagné {} kekettes !"
GAMBLE_LOST = "{} a tiré {} et a perdu {} kekettes !"
VALUE_ERROR_EXCEPTION = "Vous avez entré une valeur incorrecte"
BOT_LEAVING_CHAT = "KekettesBot a quitté le chat, au revoir !"
MADE_IT_RAIN = "Woohoo, {} fait pleuvoir des kekettes !"
DOUBLE_TROUBLE_STARTED = "{} a lancé les double points ! Tout le monde gagne le double pendant 10 minutes !"
DOUBLE_TROUBLE_ENDED = "Double points terminé !"
SOURCE_CODE_MESSAGE = "Voilà le code source pour le bot : <link>"

QUOTES = []
with open("quotes.txt", "r") as f:
    for line in f:
        QUOTES.append(line.rstrip("\n"))

next_call = time.time()

########FUNCTION HANDLES FOR CMDS###########
def sourcecode(users, text, user):
    return SOURCE_CODE_MESSAGE, users

def quote(users, text, user):
    return rd.choice(QUOTES), users

def denisbrogniart(users, text, user):
    return "AH !", users

def helpkekettes(users, text, user):
    return HELP_MESSAGE, users

def kekettes(users, text, user):
    return DISPLAY_POINTS.format(user.username.capitalize(), user.current), users
    pass

def gamble(users, text, user):
    balance = user.current
    try:
        message = text.split(":")[-1]
        gmbl = message.split()[-1]
        gmbl = int(gmbl)
        assert gmbl>0, "Amount supposed to be positive"
    except ValueError:
        return VALUE_ERROR_EXCEPTION, users
    except AssertionError:
        return VALUE_ERROR_EXCEPTION, users
    if user.may_perform_action(gmbl):
        user.add_points(-gmbl)
    else:
        return NOT_ENOUGH_POINTS.format(user.username.capitalize()), users
    rng = rd.randint(1, 100)
    if rng <50:
        return GAMBLE_LOST.format(user.username.capitalize(), rng, gmbl), users
    else:
        winnings = gmbl*(math.ceil((rng-50)/50*4)+1)
        user.add_points(winnings)
        return GAMBLE_WON.format(user.username.capitalize(), rng, winnings-gmbl), users
    pass

def doubletrouble(users, text, user):
    username = username = text.split(":")[1].split("!")[0]
    now = datetime.datetime.now().time()
    then = addSecs(now, 600)
    if user.may_perform_action(2000):
        user.add_points(-2000)
    else:
        return NOT_ENOUGH_POINTS.format(user.username.capitalize()), users
    return (then, DOUBLE_TROUBLE_STARTED.format(user.username.capitalize())), users
    pass

def versus(users, text, user):
    pass

def makeitrain(users, text, user):
    if user.may_perform_action(3000):
        user.add_points(-3000)
    else:
        return NOT_ENOUGH_POINTS.format(user.username.capitalize()), users
    for u in users:
        u.add_points(30)
    return MADE_IT_RAIN.format(user.username.capitalize()), users
    pass

##########FUNCTIONS#########
def addSecs(tm, secs):
    fulldate = datetime.datetime(100, 1, 1, tm.hour, tm.minute, tm.second)
    fulldate = fulldate + datetime.timedelta(seconds=secs)
    return fulldate.time()

#########USER CLASS###########
class User():
    """
    User class for bot users.
    Each user is reprensented as an instance of this class. See self.users in KekettesBot class.

    ---
    attributes :    username
                    user_id
                    current
                    all_time

    methods :       add_points(amount)          amount is either positive or negative, check may_perform_action if amount is negative
                    may_perform_action(cost) cost is expected positive
                    __repr__ : represents the class as username:id, current/all_time
    """
    def __init__(self, row):
        self.fieldnames = ['username', 'user_id', 'current', 'all_time']
        self.row = row
        self._username = row["username"]
        self._user_id = int(row["user_id"])
        self._current = int(row["current"])
        self._all_time = int(row['all_time'])

    def _get_username(self):
        return self._username
    def _set_username(self, new_username):
        self._username = str(new_username)
    def _get_user_id(self):
        return self._user_id
    def _set_user_id(self, id_):
        self._user_id = id_
    def _get_current(self):
        return self._current
    def _set_current(self, new_current):
        delta = int(new_current) - int(self._current)
        if delta >0:
            self._all_time = int(self._all_time) + int(delta)
        self._current = int(new_current)
    def _get_all_time(self):
        return int(self._all_time)
    def _set_all_time(self, new_all_time):
        self._all_time = int(new_all_time)
    username = property(_get_username, _set_username)
    user_id = property(_get_user_id, _set_user_id)
    current = property(_get_current, _set_current)
    all_time = property(_get_all_time, _set_all_time)

    def add_points(self, points_to_add):
        self.current += points_to_add
    def may_perform_action(self, cost):
        return self.current-cost >=0
    def __repr__(self):
        return "{}:{}, {}/{}".format(self.username, self.user_id, self.current, self.all_time)

class KeketteBot(Thread):
    def __init__(self, commands):
        Thread.__init__(self)
        self.stop = False
        #CONFIG
        self.channel_name = 'misterteamot'
        self.channel_id = 89287341
        self.channel_oauth = TARGET_OAUTH #teamot oauth
        self.number_of_messages_sent = 0
        self.max_messages = 100 #/30 sec
        self.max_joins = 50 #/15 sec
        self.base_drop_rate = 2 #per minute
        self.points_multiplier = 1
        self.csv_filename = "points.csv"
        #IRC CONFIG
        self.server = 'irc.chat.twitch.tv'
        self.port = 6667
        self.nickname = 'kekettesbot'
        self.password = BOT_OAUTH #oauth token for the bot
        self.commands = commands
        self.given_to_subs = False
        self.end_doubletrouble = datetime.datetime.now().time()
        self.doubletroublechanged = False
        self.time_start_daemon = time.time()
        self.points_not_given = True
        self.joined_users = []

        #Loader for csv data
        fields = ['username', 'user_id', 'current', 'all_time']
        #self.users = {'username':[], 'user_id':[], 'current':[], 'all_time':[]}
        self.users = []
        with open(self.csv_filename, "r") as csvfile:
            reader = csv.DictReader(csvfile, fieldnames=fields)
            i = 0
            for row in reader:
                i+=1
                if i>1:
                    self.users.append(User(row))
                    #for f in fields:
                    #   self.users[f].append(row[f])
        print(self.users)
        #IRC STUFF
        self.irc = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #defines the socket
        # Connect
        #self.irc.bind((self.server, self.port))
        self.irc.connect((self.server, self.port))
        self.irc.setblocking(False)
        self.irc.send("PASS {}\n".format(self.password).encode())
        self.irc.send("NICK {}\n".format(self.nickname).encode())
        self.irc.send("JOIN #{}\n".format(self.channel_name).encode())
        self.irc.send("PRIVMSG #{} :{}\n".format(self.channel_name, BOT_HAS_STARTED).encode("UTF-8"))
        self.irc.send("CAP REQ :twitch.tv/membership\n".encode())
        self.irc.send("CAP REQ :twitch.tv/tags\n".encode())
        #TWITCH API STUFF
        self.client_id = BOT_CLIENT_ID
        self.client = TwitchClient(self.client_id, self.channel_oauth)
        print(self.client._oauth_token)
        #self.channel = self.client.channels.get()
        current_offset = 0
        self.subscribers = []
        self.subscribers_twitch = []
        #while self.client.channels.get_subscribers(self.channel_id, limit=100, offset=current_offset):
        #   self.subscribers_twitch.extend(self.get_subscribers.get_subscribers(self.channel_id, limit=100, offset=current_offset))
        #   current_offset += 100

    def run(self):
        while not self.stop:
            with lock:
                if int(time.time()-self.time_start_daemon)%30==0:
                    self.number_of_messages_sent = 0
                if datetime.datetime.now().time() > self.end_doubletrouble and self.doubletroublechanged:
                    self.points_multiplier = 1
                    self.irc_print(DOUBLE_TROUBLE_ENDED)
                    self.doubletroublechanged = False
                if int(time.time()-self.time_start_daemon)%120==0 and self.points_not_given:#datetime.now().minute%2 == 0 and datetime.now().second == 1: #donne des kekettes toutes les 2 minutes
                    self.points_not_given = False
                    for user in self.joined_users: #TODO: les viewers qui n'ont pas encore de kekettes (les nouveaux)
                        user.add_points(self.base_drop_rate*self.points_multiplier)
                if not self.points_not_given and int(time.time()-self.time_start_daemon)%121==0:
                    self.points_not_given = True
                if datetime.datetime.now().weekday() == 0 and not self.given_to_subs: #Monday #Donne 1000 kekettes aux subs par semaine
                    self.given_to_subs = True
                    for sub in self.subscribers:
                        sub.add_points(1000)
                        #i = self.users["user_id"].index(str(sub.id_))
                        #self.users["current"][i] += 1000
                try:
                    text=self.irc.recv(4096).decode()
                    print(text)
                    # Prevent Timeout
                    if text.find('PING') != -1:
                        self.irc.send('PONG {}\r\n'.format(text.split()[1]).encode())
                        print('PONG {}\r\n'.format(text.split()[1]))
                    elif text.find("JOIN") != -1:
                        username = text[1:].split("!")[0]
                        user_id = int(self.client.users.translate_usernames_to_ids(list(username))[0].id)
                        if user_id not in [x.user_id for x in self.users]:
                            row={'username':username, 'user_id':user_id, 'current':0, 'all_time':0}
                            u = User(row)
                            self.users.append(u)
                            self.joined_users.append(u)
                        else:
                            i = [x.user_id for x in self.users].index(user_id)
                            self.joined_users.append(self.users[i])
                    elif text.find("PART") != -1:
                        username = text[1:].split("!")[0]
                        user_id = int(self.client.users.translate_usernames_to_ids(list(username))[0].id)
                        i = [x.user_id for x in self.joined_users].index(user_id)
                        self.joined_users.pop(i)
                    #If message received
                    elif text.find('PRIVMSG') != -1:
                        if "!quit" in text and "mod" in text.split("user-type=")[1].split(":")[0]:
                            self.quit()
                        for command, handle in self.commands.items():
                            if text.find(command) != -1:
                                print("Command found !")
                                username = text.split(":")[1].split("!")[0]
                                user_id = text.split("user-id=")[1].split(";")[0]
                                index = [x.user_id for x in self.users].index(int(user_id))
                                user = self.users[index]
                                print((username, user_id))
                                output, self.users = handle(self.users, text, user)
                                print(output)
                                if type(output) == type(str()):
                                    self.irc_print(output)
                                elif type(output) == type(tuple()):
                                    self.points_multiplier += 1
                                    self.end_doubletrouble = output[0]
                                    self.doubletroublechanged = True
                                    self.irc_print(output[1])
                except Exception as e:
                    if "10035" not in repr(e):
                        print("{} : {}".format(type(e), e))
                    continue

    def quit(self):
        self.irc_print(BOT_LEAVING_CHAT)
        self.irc.send('PART'.encode())
        self.irc.close()
        self.stop = True
        with open(self.csv_filename, 'w') as csvfile:
            fieldnames = ['username', 'user_id', 'current', 'all_time']
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
            writer.writeheader()
            for user in self.users:
                writer.writerow({
                'username': user.username,
                'user_id': user.user_id,
                'current': user.current,
                'all_time': user.all_time
                })
    def irc_print(self, message):
        if self.number_of_messages_sent<self.max_messages:
            self.irc.send('PRIVMSG #{} :{}\n'.format(self.channel_name, str(message)).encode("UTF-8"))
            self.number_of_messages_sent +=1

def main():
    commands = {'!kekettes':kekettes, #displays the amount of points the user has
                '!gamble':gamble, #gamble a set amount of points
                '!makeitrain':makeitrain, #gives each user 30 points
                '!doubletrouble':doubletrouble, #double the drop-rate of points for 30 minutes
                '!versus':versus, # challenge un autre viewer a un versus
                '!help':helpkekettes, #Affiche l'aide
                '!quote':quote, #affiche une quote de teamot
                '!denisbrogniart': denisbrogniart, #AH !
                '!sourcecode':sourcecode #Affiche le lien vers le code source du bot
                }
    cmds = [str(k) for k in commands.keys()]
    cmd_str = ""
    for i in cmds:
        cmd_str += i+", "
    cmd_str.rstrip(",")
    global HELP_MESSAGE
    HELP_MESSAGE = "Available Commands : {}".format(cmd_str)
    bot = KeketteBot(commands)
    print('KekettesBot is now running !')
    bot.start()

if __name__ == '__main__':
    main()
    pass