"""
Creating blog
Homework for python-courses
"""

import pymysql.cursors
import hashlib
import uuid
import time
from collections import defaultdict


class BlogApp:

    tokens_dict = defaultdict(list)

    def add_new_user(self, user_username, user_email, user_password):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        # salt = b'some_salt'
        # hash_obj = hashlib.md5()
        # hash_obj.update(salt)
        # hash_obj.update(user_password.encode('utf-8'))

        try:
            with connection.cursor() as cursor:
                sql = "INSERT INTO User (Username, Email, Password) VALUES (%s, %s, %s)"
                cursor.execute(sql, (user_username, user_email, user_password))
            connection.commit()

            with connection.cursor() as cursor:
                sql = "SELECT UserID, Username, Password FROM User WHERE Email=%s"
                cursor.execute(sql, user_email)
                result = cursor.fetchone()
                print(result)
        finally:
            connection.close()

    def authentication_user(self, user_email, user_password):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        try:
            with connection.cursor() as cursor:
                sql = "SELECT UserID FROM User WHERE Email=%s AND Password=%s"
                cursor.execute(sql, (user_email, user_password))
                user_id = cursor.fetchone()
                if user_id is not None:
                    user_token = uuid.uuid4()
                    self.tokens_dict[user_token].append(user_id)
                else:
                    raise KeyError('Login | Password Error')
                connection.commit()

        finally:
            connection.close()

        return user_token

    def get_users_list(self):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        try:
            with connection.cursor() as cursor:
                sql = "SELECT Username FROM User"
                cursor.execute(sql)
                result = cursor.fetchall()
                connection.commit()

        finally:
            connection.close()
        print(result)
        return result

    def get_auth_user_blogs_list(self, user_token):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        if user_id is None:
            raise KeyError('Incorrect user token')

        try:
            with connection.cursor() as cursor:
                sql = "SELECT BlogID, BlogName, BlogDescription FROM Blog WHERE UserID=%s"
                cursor.execute(sql, user_id)
                result = cursor.fetchall()
                connection.commit()
        finally:
            connection.close()
        return result

    def get_blogs_list(self):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        try:
            with connection.cursor() as cursor:
                sql = "SELECT BlogName, BlogDescription FROM Blog"
                cursor.execute(sql)
                result = cursor.fetchall()
                connection.commit()

        finally:
            connection.close()
        print(result)
        return result

    def create_blog(self, blog_name, blog_description, user_token):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        if user_id is None:
            raise KeyError('Incorrect user token')
        try:
            with connection.cursor() as cursor:
                sql = "INSERT INTO Blog (BlogDescription, UserID, BlogName) VALUES (%s, %s, %s)"
                cursor.execute(sql, (blog_description, user_id, blog_name))
            connection.commit()

            with connection.cursor() as cursor:
                sql = "SELECT * FROM Blog WHERE BlogName=%s"
                cursor.execute(sql, blog_name)
                result = cursor.fetchall()
                print(result)
        finally:
            connection.close()

    def edit_blog(self, user_token, blog_id, changed_name=None, changed_description=None):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        print(user_id)
        if user_id is None:
            raise KeyError('Incorrect user token')
        try:
            with connection.cursor() as cursor:
                sql = "SELECT UserID FROM Blog WHERE BlogID=%s"
                cursor.execute(sql, blog_id)
                blogs_user_id = cursor.fetchone()
                print(blogs_user_id.get('UserID'))
            connection.commit()

            if blogs_user_id.get('UserID') == user_id:
                with connection.cursor() as cursor:
                    if changed_name is not None:
                        sql = "UPDATE Blog SET BlogName=%s WHERE BlogID=%s"
                        cursor.execute(sql, (changed_name, blog_id))
                    if changed_description is not None:
                        sql = "UPDATE Blog SET BlogDescription=%s WHERE BlogID=%s"
                        cursor.execute(sql, (changed_description, blog_id))
                connection.commit()
            else:
                raise ValueError('You don\'t have enough permission to edit someones blog')
        finally:
            connection.close()

    def delete_blog(self, blog_id, user_token):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        if user_id is None:
            raise KeyError('Incorrect user token')
        try:
            with connection.cursor() as cursor:
                sql = "SELECT UserID FROM Blog WHERE BlogID=%s"
                cursor.execute(sql, blog_id)
                blogs_user_id = cursor.fetchone()
                print(blogs_user_id.get('UserID'))
            connection.commit()

            if blogs_user_id.get('UserID') == user_id:
                with connection.cursor() as cursor:
                    sql = "DELETE FROM Blog WHERE BlogID=%s"
                    cursor.execute(sql, blog_id)
                connection.commit()
            else:
                raise ValueError('You don\'t have enough permission to delete someones blog')
        finally:
            connection.close()

    def create_post(self, user_token, blog_id, post_description, post_name):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        if user_id is None:
            raise KeyError('Incorrect user token')
        try:
            with connection.cursor() as cursor:
                sql = "INSERT INTO Post (UserID, BlogID, PostDescription, PostName) VALUES (%s, %s, %s, %s)"
                cursor.execute(sql, (user_id, blog_id, post_description, post_name))
            connection.commit()
        finally:
            connection.close()

    def edit_post(self, user_token, post_id, changed_name=None, changed_description=None):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        if user_id is None:
            raise KeyError('Incorrect user token')
        try:
            with connection.cursor() as cursor:
                sql = "SELECT UserID FROM Post WHERE PostID=%s"
                cursor.execute(sql, post_id)
                post_user_id = cursor.fetchone()
                if post_user_id is None:
                    raise ValueError('There is no your post with this post_id')
            connection.commit()

            if post_user_id.get('UserID') == user_id:
                with connection.cursor() as cursor:
                    if changed_name is not None:
                        sql = "UPDATE Post SET PostName=%s WHERE PostID=%s"
                        cursor.execute(sql, (changed_name, post_id))
                    if changed_description is not None:
                        sql = "UPDATE Post SET PostDescription=%s WHERE PostID=%s"
                        cursor.execute(sql, (changed_description, post_id))
                connection.commit()
            else:
                raise ValueError('You don\'t have enough permission to edit someones post')
        finally:
            connection.close()

    def delete_post(self, user_token, post_id):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        if user_id is None:
            raise KeyError('Incorrect user token')
        try:
            with connection.cursor() as cursor:
                sql = "SELECT UserID FROM Post WHERE PostID=%s"
                cursor.execute(sql, post_id)
                post_user_id = cursor.fetchone()
                if post_user_id is None:
                    raise ValueError('There is no your post with this post_id')
            connection.commit()

            if post_user_id.get('UserID') == user_id:
                with connection.cursor() as cursor:
                    sql = "DELETE FROM Post WHERE PostID=%s"
                    cursor.execute(sql, post_id)
                    connection.commit()
            else:
                raise ValueError('You don\'t have enough permission to delete someones blog')
        finally:
            connection.close()

    def add_comment(self, user_token, comment_body, post_id, parrent_id=None):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        if user_id is None:
            raise KeyError('Incorrect user token')
        try:
            if parrent_id is not None:
                with connection.cursor() as cursor:
                    sql = "SELECT CommentID FROM Comment WHERE PostID=%s"
                    cursor.execute(sql, post_id)
                    result = cursor.fetchall()
                    if result is None:
                        raise ValueError('There is no comment with this comment_id')

                for comment in result:
                    if parrent_id == comment.get('CommentID'):
                        with connection.cursor() as cursor:
                            sql = "INSERT INTO Comment (UserID, CommentBody, PostID, ParrentID) VALUES (%s, %s, %s, %s)"
                            cursor.execute(sql, (user_id, comment_body, post_id, parrent_id))
                        break
            else:
                with connection.cursor() as cursor:
                    sql = "INSERT INTO Comment (UserID, CommentBody, PostID) VALUES (%s, %s, %s)"
                    cursor.execute(sql, (user_id, comment_body, post_id))
            connection.commit()
        finally:
            connection.close()

    def get_user_comments(self, user_token):
        connection = pymysql.connect(host='localhost',
                                     user='BlogApp_User',
                                     password='BlogApp_Password',
                                     db='BlogApp',
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)

        user_id = self.tokens_dict.get(user_token)[0].get('UserID')
        if user_id is None:
            raise KeyError('Incorrect user token')

        try:
            with connection.cursor() as cursor:
                sql = "SELECT CommentID, CommentBody FROM Comment WHERE UserID=%s"
                cursor.execute(sql, user_id)
                result = cursor.fetchall()
                connection.commit()
        finally:
            connection.close()
        return result


blog = BlogApp()

# print(a.tokens_dict)
# blog.add_new_user('sexybeast', '111@gmail.com', '111')
# print(blog.tokens_dict)
user_token = blog.authentication_user('111@gmail.com', '111')
# print(blog.tokens_dict)
# blog.create_blog('say my name', 'you god damn right', user_token)
# blog.edit_blog(5, user_token, 'son', 'where did you find this???')
# blog.delete_blog(5, user_token)
# my_blogs = blog.get_auth_user_blogs_list(user_token)
# for blog in my_blogs:
#   print(blog)
# blog.create_post(user_token, 2, 'read a few pages of this shit, it\'s fucking awesome', 'new experience')
# blog.delete_post(user_token, 2)
# blog.edit_post(user_token, 2, 'more_new_experience', 'ziga-zaga-hoi-hoi-hoi')
# blog.add_comment(user_token, 'god knows it would be the first time', 2)
# blog.add_comment(user_token, 'replying your gay-gay-shit back', 2, 4)

# my_comments = blog.get_user_comments(user_token)
# for comment in my_comments:
#    print(comment)