import json
from collections import defaultdict
from datetime import datetime
import telebot
from telebot.types import Message
import requests
import sqlite3
from logging import getLogger, StreamHandler
from datetime import  date

logger = getLogger(__name__)
logger.addHandler(StreamHandler())
logger.setLevel('INFO')


CREATE_QUERY = '''
    CREATE TABLE IF NOT EXISTS users(
        user_id int, 
        user_name text,
        chat_id int
        
    );
    
    '''
CREATE_REMIND_TABLE = '''
    CREATE TABLE IF NOT EXISTS users_remind(
    user_id int,
    remind text
    );

'''


class SQLiteClient:
    def __init__(self, filepath: str):
        self.filepath = filepath
        self.conn = None
        self.conn_remind = None


    def create_conn(self):
        self.conn = sqlite3.connect(self.filepath, check_same_thread=False)
        self.conn_remind = sqlite3.connect(self.filepath, check_same_thread=False)

    def create_conn_remind(self):
        self.conn_remind = sqlite3.connect(self.filepath, check_same_thread=False)


    def close_conn(self):
        self.conn = conn.close()
        self.conn_remind = conn.close()


    def execute_command(self, command: str, params: tuple):
        if self.conn is not None:
            self.conn.execute(command, params)
            self.conn.commit()
        else:
            raise ConnectionError('Nope')
        if self.conn_remind is not None:
            self.conn_remind.execute(command, params)
            self.conn_remind.commit()
        else:
            raise ConnectionError('Nope')

    def execute_select_command(self, command: str):
        if self.conn is not None:
            cur = self.conn.cursor()
            cur.execute(command)
            return cur.fetchall()
        else:
            raise ConnectionError('Nope')
        if self.conn_remind is not None:
            cur = self.conn_remind.cursor()
            cur.execute(command)
            return cur.fetchall()
        else:
            raise ConnectionError('Nope')

class UserActioner:
    CREATE_USER = '''
        INSERT INTO users (user_id, user_name, chat_id) VALUES (?,?,?)
        '''
    GET_USER = '''
        SELECT user_id, user_name, chat_id FROM users WHERE user_id = %s;
        '''

    CREATE_USER_REMIND = '''
        INSERT INTO users_remind (user_id, remind) VALUES (?,?)
        '''

    GET_USER_REMIND = '''
        SELECT user_id, remind FROM users_remind WHERE user_id = %s
        '''


    def __init__(self, database_client: SQLiteClient):
        self.database_client = database_client

    def setup(self):
        self.database_client.create_conn()
        self.database_client.create_conn_remind()

    def get_user(self, user_id: str):
        user = self.database_client.execute_select_command(self.GET_USER % user_id)
        return user[0] if user else []


    def create_user(self, user_id: str, user_name: str, chat_id: int):
        self.database_client.execute_command(self.CREATE_USER, (user_id, user_name, chat_id))

    def create_remind(self, user_id: str, remind: str):
        self.database_client.execute_command(self.CREATE_USER_REMIND, (user_id, remind))

    def get_remind(self, user_id: str):
        remind = self.database_client.execute_command(self.GET_USER_REMIND % user_id)
        return remind[0] if user else []

    def shutdown(self):
        self.database_client.close_conn()

    def create_user_remind(self, user_id: str, remind: str):
        self.database_client.execute_command(self.CREATE_USER_REMIND, (user_id, remind))



class TelegramClient:
    def __init__(self, token: str, base_url: str):
        self.token = token
        self.base_url = base_url

    def prepare_url(self, method: str):
        result_url = f'{self.base_url}/bot{self.token}/'
        if method is not None:
            result_url += method
        return result_url

    def post(self, method: str = None, params: dict = None, body: dict = None):
        url = self.prepare_url(method)
        resp = requests.post(url, params=params, data=body)
        return resp.json()

if __name__ == '__main__':
    TOKEN = ************
    user_actioner = UserActioner(SQLiteClient('users.db'))
    user_actioner2 = UserActioner(SQLiteClient('users_remind.db'))
    telegram_client = TelegramClient(token = TOKEN, base_url='https://api.telegram.org')
    my_params = {'chat_id': 857813877, 'text': 'Sample'}
    print(telegram_client.post(method='sendMessage', params=my_params))



class MyBot(telebot.TeleBot):
    def __init__(self, telegram_client: TelegramClient, user_actioner: UserActioner, user_actioner2: UserActioner, *args, **kwargs ):
        super().__init__(*args, **kwargs)
        self.telegram_client = telegram_client
        self.user_actioner = user_actioner
        self.user_actioner2 = user_actioner2

    def setup_resourses(self):
        self.user_actioner.setup()

    def setup_resourses2(self):
        self.user_actioner2.setup()

    def shutdown_resourses(self):
        self.user_actioner.shutdown()
        self.user_actioner2.shutdown()

    def shutdown(self):
        self.shutdown_resourses()

bot = MyBot(token=TOKEN, telegram_client=telegram_client, user_actioner=user_actioner, user_actioner2=user_actioner2)
bot.setup_resourses()
bot.setup_resourses2()
conn = sqlite3.connect('users.db')
conn2 = sqlite3.connect('users_remind.db')
conn.execute(CREATE_QUERY)
conn2.execute(CREATE_REMIND_TABLE)
conn.commit
conn2.commit



@bot.message_handler(commands=["start"])
def start(message: Message):  # создаем библиотеку, которая поможет передать информацию о человеке
    with open("users.json", "r") as f_o:  #нужно для передачи информации для пользователя
        data_from_json = json.load(f_o)  #нужно для передачи информации для пользователя

    user_id = message.from_user.id
    user_name = message.from_user.first_name
    chat_id = message.chat.id

    bot.user_actioner.create_user(user_id=str(user_id), user_name=user_name, chat_id=chat_id)

    if str(user_id) not in data_from_json: #нужно для передачи информации для пользователя
        data_from_json[user_id] = {"user_name": user_name}  #нужно для передачи информации для пользователя

    with open("users.json", "w") as f_o: # нужно для передачи информации для пользователя
        json.dump(data_from_json, f_o, indent=4, ensure_ascii=False) #нужно для передачи информации для пользователя
    bot.reply_to(message=message, text="Вы начали взаимодействовать со мной, " + message.chat.first_name + " 😇") # бот ответит на сообщение
    print(message.chat.id)



user_by_messages = defaultdict(list)
messages = []
@bot.message_handler(commands=["remind"])
@bot.message_handler(func=lambda message: True)
def remind(message: Message):


    bot.reply_to(message=message, text="⏰ Напиши время для напоминания, в формате - часы:минуты")
    user_id = message.from_user.id
    bot.register_next_step_handler(message, handle_remind_verify)


def handle_remind_verify(message: Message):
    if message.text != '/remind':
        user_id = message.from_user.id
        bot.user_actioner.create_user_remind(user_id=str(user_id), remind=message.text)
        bot.reply_to(message, 'Зареган.')


    else:
        bot.reply_to(message, text="⏰ Напиши: время | дату | текст, для своего напоминания ")



def handle_remind_step(message: Message):
    bot.reply_to(message, "С этим разобрались, а теперь напиши сам текст напоминания")


def handle_remind_added(message: Message):

    bot.reply_to(message, "Напоминание успешно установлено ✅")
def handle_remind_true(message: Message):


    if message.text != '/remind':
        bot.reply_to(message, "Ваше напоминание:  " + message.text + ", верно?")



while True:
    try:
        bot.setup_resourses()
        bot.setup_resourses2()
        bot.polling()
    except Exception as err:

        print("Ошибка JSON-file", err)
        requests.post("https://api.telegram.org/bot5889926588:"
                         f"AAEg4TkG9NN_ytupCnZcGC0DixHXCyWj1h8/sendMessage?chat_id=857813877&text={datetime.now()} —> {err.__class__} —> {err}")