# -*- coding: utf-8 -*-

import socket
import sys
import re
from time import sleep, time
import errno

import pymysql.cursors
import random

from btts import btts

from config import *

tts = btts()

CHANNEL = 'sentdex'

# Connect to the database
connection = pymysql.connect(host=IP,
                             user=USERNAME,
                             password=PASSWORD,
                             db=DB,
                             charset='utf8mb4',
                             use_unicode=True,
                             cursorclass=pymysql.cursors.DictCursor,
                             autocommit=True)

with connection.cursor() as cursor:
    cursor.execute('SET NAMES utf8mb4')
    cursor.execute('SET character_set_client="utf8mb4"')


def modify_input(string):
    tokenized = string.split(' ')
    if tokenized[0] == '@Charles_the_AI':
        string = ' '.join([i for i in tokenized[1:]])
    if '@Charles_the_AI' in string:
        string = string.replace('@Charles_the_AI', 'Charles')

    if '@charles_the_ai' in string:
        string = string.replace('@charles_the_ai', 'Charles')

    if '@Charles_the_ai' in string:
        string = string.replace('@Charles_the_ai', 'Charles')

    if '@Charles_The_AI' in string:
        string = string.replace('@Charles_The_AI', 'Charles')

    if '@CharlestheAI' in string:
        string = string.replace('@CharlestheAI', 'Charles')

    if '@charlestheai' in string:
        string = string.replace('@charlestheai', 'Charles')

    if '@Charlestheai' in string:
        string = string.replace('@Charlestheai', 'Charles')

    if '@CharlesTheAI' in string:
        string = string.replace('@CharlesTheAI', 'Charles')

    if 'CharlesTheAI' in string:
        string = string.replace('CharlesTheAI', 'Charles')
    if 'charlestheai' in string:
        string = string.replace('charlestheai', 'Charles')

    # string = re.sub(r"(?<=^|(?<=[^a-zA-Z0-9-_\\.]))@([A-Za-z]+[A-Za-z0-9_]+)","that person",string)

    string = string.strip()

    # string = string.replace('<3', '&lt;3')

    return string


def say_something(original, thing, user):
    ##'''
    ##engine = pyttsx3.init()
    ##voices = engine.getProperty('voices')
    ##for voice in voices:
    ##engine.setProperty('voice', 'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\Voices\Tokens\TTS_MS_EN-US_ZIRA_11.0')
    ##print(voice.id)
    ##engine.say('The quick brown fox jumped over the lazy dog.')
    ##engine.runAndWait()
    ##'''

    punc_dict = {"!": ['exclaims', 'yells', 'shouts', 'cries', 'roars', 'hollers', ],
                 "?": ['wonders', 'asks', 'inquires', 'is curious', 'wants to know'],
                 ".": ['says', 'states', 'declares', 'proclaims']}

    try:
        user_emote = random.choice(punc_dict[original[-1]])
    except:
        user_emote = random.choice(punc_dict['.'])

    # original = original.replace('&lt;3', '<3')
    original = '{} {}: {}'.format(user, user_emote, original)

    tts.speak({
        'phrases': [
            {
                'text': "{}".format(original),
                'voice': 'Google UK English Female',
            },
            {
                'text': "{}".format(thing.replace("$000", "One million dollars").replace("0'0 '",
                                                                                         "{} centimeters".format(str(
                                                                                             random.randrange(183,
                                                                                                              213)))).replace(
                    "00", str(random.randrange(1, 99))).replace("0", str(random.randrange(0, 9))).replace('00', str(
                    random.randrange(11, 99)))),
                'voice': 'Google UK English Male',
            }
        ],
        'source': 'Twitch'
    })


def check_mentions(mentions):
    for mention in mentions:
        try:
            with connection.cursor() as cursor:

                # check to see if user has already asked this message in the last 10 minutes?
                # check to see if user has asked more than 30 questions in the last 3600 seconds

                if 'charlestheai' in mention['message'].lower():

                    # mention['message'] = mention['message'].replace('<3', '&lt;3')
                    print('Yes, a charles mention', mention['message'])

                    # check to see if someone recently said this same thing in the last 5 minutes
                    sql = "SELECT `id` FROM `chat_nmt` WHERE `question`=%s AND `unix` > %s"
                    cursor.execute(sql, (mention['message'], int(time() - 300)))  # last 5 minutes
                    result1 = cursor.fetchone()

                    # check to see if any one user has asked more than 30 questions in the last hour
                    sql = "SELECT `id` FROM `chat_nmt` WHERE `source_id`=%s AND `unix` > %s"
                    cursor.execute(sql, (mention['user'], int(time() - 3600)))  # last 5 minutes
                    result2 = cursor.fetchall()

                    if result1 == None and len(result2) <= 60:
                        # Create a new record
                        sql = "INSERT INTO `chat_nmt` (`unix`, `question`, `source`, `source_id`, `type`) VALUES (%s, %s, %s, %s, %s)"
                        cursor.execute(sql, (
                        str(int(time())), mention['message'], 'twitch', mention['user'], 'twitch_mention'))
            #connection.commit()
        except Exception as e:
            print(str(e))


def check_to_reply():
    global last_msg

    unk_msgs = ['Hmm, I do not understand.',
                'Try asking in another way.',
                'I am confused with the question.',
                'I do not know how to answer']

    with connection.cursor() as cursor:
        # check to see if that record exists:
        sql = "SELECT `id`, `question`,`response`, `source_id`, `type` FROM `chat_nmt` WHERE `source` = 'twitch' and `responded` = 0 and `response` IS NOT NULL"
        cursor.execute(sql)
        results = cursor.fetchall()

        replies = []
        for result in results:
            try:
                print(result)
                # Create a new record
                print(result)
                r_id = result['id']
                r_question = result['question']
                r_response = result['response']
                r_source_id = result['source_id']
                r_type = result['type']

                sql = "UPDATE chat_nmt SET `responded`=%s WHERE `id`=%s"
                cursor.execute(sql, (1, r_id))

                replies.append([r_source_id, r_question, r_response])

                if '_UNK' not in r_response:
                    say_something(modify_input(r_question), r_response, r_source_id)
                    last_msg = time()

                if '_UNK' in r_response:
                    twitch.sendMessage("@{} {}".format(r_source_id, random.choice(unk_msgs)))
                    last_msg = time()









            except Exception as e:
                print(str(e))
    #connection.commit()
    return replies


class Twitch():
    # socket settings
    socket = {}
    host = None
    port = None
    nickname = None
    tiken = None
    channel = None

    received_messages = []

    log_file = None

    DEBUG = True

    # init
    def __init__(self, nickname, token, channel, log_file='twitchlog.txt', host='irc.chat.twitch.tv', port=6667):

        # set properties
        self.host = host
        self.port = port
        self.nickname = nickname
        self.token = token
        self.channel = channel
        self.log_file = open(log_file, 'w', encoding='utf-8')

        # connect
        self.connect()

    # tick
    def tick(self):
        self.checkForNewData()
        self.sendMessages()
        self.ping()

    # connect to Twitch IRC server
    def connect(self):

        self.info("Connecting to Twitch IRC server")

        # setup socket
        self.socket = {
            'name': "twitch-irc",
            'socket': socket.socket(socket.AF_INET, socket.SOCK_STREAM),
            'buffer': "",
            'last_msg': time(),
            'last_ping_response': time(),
            'next_ping': time() + 5,
            'delimiter': "\r\n",
            'messages': []
        }

        # connect
        self.socket['socket'].settimeout(5)
        try:
            self.socket['socket'].connect((self.host, self.port))
        except IOError as e:
            self.info("%s (%s)" % (e.errno, e.strerror), "ERROR:  ")
            self.socket = None
            return False
        except:
            self.info("Unexpected error: %s" % sys.exc_info()[0], "ERROR:  ")
            self.socket = None
            return False

        # set nonblocking connection
        self.socket['socket'].setblocking(0)

        self.info("Connected")

        # log in
        self.info("Logging in")
        self.socketWrite("CAP REQ :twitch.tv/tags")
        self.socketWrite("CAP REQ :twitch.tv/commands")
        self.socketWrite("CAP END")
        self.socketWrite("PASS oauth:%s" % self.token)
        self.socketWrite("NICK %s" % self.nickname.lower())

        # wait for response
        flag = False
        for i in range(500):
            sleep(0.01)

            # check if there is any response
            data = self.socketRead()

            # if true
            if data:

                # parse data
                response = self.parseChatLine(data)

                # we are logged in now
                if response['status'] == 'info' and not flag:
                    self.info("Logged in")
                    flag = True
                    break

                # Twitch returned error message
                elif response['status'] == 'error':
                    self.info("Login failed", "ERROR:  ")
                    self.socket = None
                    return False

            # connection error?
            elif data is not None:
                self.socket = None
                return False

        # after 5 seconds long loop if there is no response still - error
        if not flag:
            self.info("Login failed", "ERROR:  ")
            self.socket = None
            return False

        # join channel
        self.info("Joining #%s" % self.channel)
        self.socketWrite("JOIN #%s" % self.channel)

        # wait for response
        flag = False
        for i in range(500):
            sleep(0.01)

            # check if there is any response
            data = self.socketRead()

            # if true
            if data:

                # parse data
                response = self.parseChatLine(data)

                # joined a channel
                if response['status'] == 'join' and not flag:
                    self.info("Joined #%s" % self.channel)
                    flag = True
                    break

            # connection error?
            elif data is not None:
                self.socket = None
                return False

        # after 5 seconds long loop if there is no response still - error
        if not flag:
            self.info("Joining failed", "ERROR:  ")
            self.socket = None
            return False

    # parse irc command
    def parseChatLine(self, line):

        # ping
        if line == "PING :tmi.twitch.tv":
            self.socketWrite("PONG :tmi.twitch.tv")
            return {'status': 'ping'}

        # pong
        elif "PONG tmi.twitch.tv" in line:
            self.socket['last_ping_response'] = time()
            return {'status': 'pong'}

        # parse line
        line = re.search(
            "(?:(?P<badges>[^\s]+) )?:(?P<host>[^\s]+) (?P<code>[^\s]+) (?P<info>[^\s]+)( (?P<message>.*))?", line)
        if line:
            message = line.groupdict().get('message', '')
            message = message[1:] if message and message.startswith(":") else message  # drop first colon

            # join
            if line.group('code') == "JOIN":
                return {'status': 'join'}

            # notice
            elif line.group('code') == "NOTICE":
                self.info(message, "NOTICE: ")
                if message == "Login authentication failed":
                    return {'status': 'error'}
                else:
                    return {'status': 'notice'}

            # msg https://dev.twitch.tv/docs/v5/guides/irc/#privmsg-twitch-tags
            elif line.group('code') == 'PRIVMSG':
                user = re.search("!(?P<user>.*?)@", line.group('host'))
                bits = re.search("bits=(?P<bits>.*?);", line.group('badges'))
                subscriber = re.search("subscriber=(?P<subscriber>.*?);", line.group('badges'))
                if bits and bits.group('bits'):
                    return {'status': 'cheer', 'user': user.group('user'), 'message': message,
                            'bits': int(bits.group('bits'))}
                else:
                    return {'status': 'message', 'user': user.group('user'), 'message': message,
                            'subscriber': bool(int(subscriber.group('subscriber')))}

            # sub or resub https://dev.twitch.tv/docs/v5/guides/irc/#usernotice-twitch-tags
            elif line.group('code') == 'USERNOTICE':
                user = re.search("display-name=(?P<user>.*?);", line.group('badges'))
                if not user.group('user'):
                    user = re.search("login=(?P<user>.*?);", line.group('badges'))
                wessage = re.search("system-msg=(?P<chatmessage>.*?);", line.group('badges'))
                if message is None:
                    message = ''
                return {'status': 'sub', 'user': user.group('user'), 'message': message,
                        'chatmessage': str(chatmessage.group('chatmessage')).replace("\s", " ")}

            # info status
            else:
                if str(line.group('code')).isnumeric():
                    return {'status': 'info'}
                line.group('code').isnumeric()

        # unrecognized command
        return {'status': 'unrecognized'}

    # still connected?
    def checkIfConnected(self):

        # if socket not exists
        if not self.socket:

            # connection is lost
            self.info("Connection to Twitch lost. Reconnecting in 5 seconds...", "ERROR:  ")
            sleep(5)
            self.connect()
            if not self.socket:
                return False

        return True

    # check for incoming packets
    def checkForNewData(self):

        # if socket exists
        if self.socket:

            # grab all chat lines
            while True:

                # grab one chat line
                data = self.socketRead()

                # if there is some data - parse it
                if data:
                    message = self.parseChatLine(data)

                    # if message is unrecognized - drop it
                    if message['status'] == 'unrecognized':
                        continue

                    # append message to a list of received messages
                    self.received_messages.append(message)

                # no new data
                elif data is None:
                    break

                # connection errors
                else:
                    self.socket = None
                    break

    # send message from list to chat
    def sendMessages(self):

        # if socket exists and there are messages to be sent back
        if self.socket and len(self.socket['messages']):

            # if time less than 0.5s from last sent message
            if time() - self.socket['last_msg'] <= 0.5 or len(self.socket['messages']) == 0:
                return

            # includes callback?
            callback = None
            if type(self.socket['messages'][0]) is list:
                callback = self.socket['messages'][0][1]
                self.socket['messages'][0] = self.socket['messages'][0][0]

            # send response from list to chat
            response = self.socketWrite(self.socket['messages'][0])

            # if successful
            if response:

                # remove message from list
                self.socket['messages'].pop(0)

                # callback?
                if callback is not None:
                    callback()

            # connection errors
            else:
                self.socket = None

            # update time stamp of last sent message
            if self.socket:
                self.socket['last_msg'] = time()

    # append message to list
    def sendMessage(self, message):

        # message with callback
        if type(message) is list:
            message[0] = "PRIVMSG #%s :%s" % (self.channel, message[0])

        # just message
        else:
            message = "PRIVMSG #%s :%s" % (self.channel, message)

        # append message to a list
        self.socket['messages'].append(message)

    # get new messages
    def getMessages(self):

        messages = self.received_messages
        self.received_messages = []
        return messages

    # ping irc
    def ping(self):

        # socket exists and time to ping?
        if self.socket and self.socket['next_ping'] < time():

            # write message directly to a socket
            response = self.socketWrite("PING :tmi.twitch.tv")

            # connection errors?
            if not response:
                self.socket = None
                return False

            # set time stamp of next ping
            self.socket['next_ping'] += 60

        # check if there is a response for a ping - if not, connection is lost
        if self.socket and self.socket['next_ping'] > self.socket['last_ping_response'] + 130:
            self.socket = None

    # write to a log file
    def info(self, line, type="INFO:   "):
        self.log_file.write("%s%s\n" % (type, line))
        self.log_file.flush()

    # read from socket, process one line
    def socketRead(self):

        # get up to 4096 bytes from socket
        try:
            self.socket['buffer'] += self.socket['socket'].recv(4096).decode("utf-8")
        except IOError as e:
            if e.errno != errno.EAGAIN and e.errno != errno.EWOULDBLOCK:
                self.info("Receiving data error: %s (%s)" % (e.errno, e.strerror), "ERROR:  ")
                return False
        except:
            self.info("Unknown receiving data error: %s" % sys.exc_info()[0], "ERROR:  ")
            return False

        # if there is at least one full line
        if not self.socket['delimiter'] or self.socket['delimiter'] in self.socket['buffer']:

            # split by delimiter, store in buffer and get one line
            if self.socket['delimiter']:
                (line, self.socket['buffer']) = self.socket['buffer'].split(self.socket['delimiter'], 1)

            # just one full line
            else:
                line = self.socket['buffer']
                self.socket['buffer'] = ""

            # write received message to a log
            if self.DEBUG and line:
                self.info(line, "DEBUG:  %s: < " % self.socket['name'])

            # return chat message
            return line

        # no new data
        return None

    # write one line to socket
    def socketWrite(self, line):

        # write message to socket
        try:
            self.socket['socket'].send(("%s%s" % (line, self.socket['delimiter'])).encode('utf-8'))
        except IOError as e:
            if e.errno != errno.EAGAIN and e.errno != errno.EWOULDBLOCK:
                self.info("Writing data error: %s (%s)" % (e.errno, e.strerror), "ERROR:  ")
                return False
        except:
            self.info("Unknown writing data error: %s" % sys.exc_info()[0], "ERROR:  ")
            return False

        # write sent message to a log
        if self.DEBUG:
            self.info(line.replace('\n', '\\n'), "DEBUG:  %s: > " % self.socket['name'])

        return True


# example:
if __name__ == '__main__':

    twitch = Twitch('CharlesTheAI', '88m15rbrvxdzrd29rsjrgst2i2mlu3', CHANNEL)
    # twitch = Twitch('AICharlesBot', 'uxyngxigcs02qs4cfcdo2xqvqxi79x', 'daniel_kukiela')

    twitch.sendMessage("Hello everyone!")
    last_msg = time()

    # connect to twitch
    # nickname, token, channel, log file (optional, default: ./twitchlog.txt), host (optional, default: irc.chat.twitch.tv), port (optional, default: 6667)
    # main loop
    bored_msgs = ['Hello!',
                  'Hello, anyone there?',
                  'What is everyone up to?',
                  'Hi there!',
                  'Greetings humans.',
                  'Hello humans?',
                  ]

    while True:
        try:
            # still connected?
            if not twitch.checkIfConnected():
                continue

            # get messages
            messages = twitch.getMessages()
            print(messages)
            print(last_msg)
            replies = check_to_reply()
            check_mentions(messages)
            # possible message objects:
            # {'status': 'message', 'user': 'twitch_username', 'message': 'message_body', 'subscriber': is_viewer_a_subcriber}
            # {'status': 'cheer', 'user': 'twitch_username', 'message': 'message_body', 'bits': number_of_bits}
            # {'status': 'sub', 'user': 'twitch_username', 'message': 'message_body', 'chatmessage': subscription_message} - chatmessage is a system message like "xxx has subscribed for y month(s)..."
            # ignore messages with other statuses


            if time() - last_msg > 300:
                twitch.sendMessage(random.choice(bored_msgs))
                last_msg = time()

            # you can also send a message with callback, callback will be called at the moment message is physically sent to a chat
            # (sendMessage method placies it in a list of messages to be sent asap)
            # a callback might be acquired by calling getattr(self, 'some_method')
            # twitch.sendMessage(["Some message", getattr(self, 'some_method')])

            # that has to be called just before end of loop
            twitch.tick()

            # wait for 1s (as this loop is sending message every passage)
            # should be 0.01s
            sleep(5)
            # sleep(0.01)

        except Exception as e:
            sleep(30)
            print(str(e))
            # Connect to the database
            # Connect to the database
            connection = pymysql.connect(host=IP,
                                         user=USERNAME,
                                         password=PASSWORD,
                                         db=DB,
                                         charset='utf8mb4',
                                         use_unicode=True,
                                         cursorclass=pymysql.cursors.DictCursor,
                                         autocommit=True)
            with connection.cursor() as cursor:
                cursor.execute('SET NAMES utf8mb4')
                cursor.execute('SET character_set_client="utf8mb4"')

            sleep(5)