import datetime
import random
import sys
import traceback

from background_task import background
from background_task import models as taskmodels
from django.conf import settings
from django.db.models import Count
from django.utils import timezone
from telegram.bot import Bot
from telegram.parsemode import ParseMode
from telegram.error import BadRequest

from . import models


@background()
def captcha_kicker():
    captcha_kicker(schedule=5)
    for pendingCaptchaUser in models.PendingCaptchaUser.objects.all():
        td: datetime.timedelta = (pendingCaptchaUser.created + datetime.timedelta(seconds=pendingCaptchaUser.lifetime)) - timezone.now()
        sec_remain = int(td.total_seconds())
        if sec_remain < 0:
            if sec_remain < -1800:
                pendingCaptchaUser.delete()
                continue
            bot_token = pendingCaptchaUser.bot_token
            bot = Bot(token=bot_token)
            try:
                bot.delete_message(
                    chat_id=pendingCaptchaUser.group.telegram_id,
                    message_id=pendingCaptchaUser.captcha_message_id,
                )
            except:
                traceback.print_exc()
            try:
                bot.kick_chat_member(
                    chat_id=pendingCaptchaUser.group.telegram_id,
                    user_id=pendingCaptchaUser.user.telegram_id,
                )
            except:
                traceback.print_exc()
            try:
                bot.unban_chat_member(
                    chat_id=pendingCaptchaUser.group.telegram_id,
                    user_id=pendingCaptchaUser.user.telegram_id,
                )
            except:
                traceback.print_exc()
            pendingCaptchaUser.delete()


@background()
def clean_logs():
    clean_logs(schedule=200)
    TaskModels = [
        taskmodels.CompletedTask,
        taskmodels.Task,
    ]
    for TaskModel in TaskModels:
        for task_name in set(map(lambda a: a['task_name'], TaskModel.objects.values('task_name'))):
            for unwanted_object in taskmodels.Task.objects.filter(task_name=task_name).order_by('-id').all()[100:]:
                unwanted_object.delete()


@background()
def dispatch_periodic_messages():
    dispatch_periodic_messages(schedule=30)
    print('dispatch_periodic_messages')
    now = timezone.now()
    for group_preferences in models.GroupPreferences.objects.filter(planned_message_enabled=True).all():
        bot_token = None
        pmi = group_preferences.planned_message_issuer
        if pmi is not None:
            bot_token = pmi.token
        else:
            bot_token = settings.TELEGRAM_TOKEN
        pending_message_dispatch = list(filter(
            lambda pmd: False if (tnd := pmd.time_next_dispatch) is None else tnd <= now,
            group_preferences.planned_message_dispatches.all(),
        ))
        if len(pending_message_dispatch) > 0:
            planned_messages = list(group_preferences.planned_messages.all())
            bot = None
            for dispatch_request in pending_message_dispatch:
                requested_tag_set = set(dispatch_request.tags_as_list)
                compatible_messages = list(filter(
                    lambda planned_message: requested_tag_set.intersection(planned_message.tags_as_list),
                    planned_messages,
                ))
                if len(compatible_messages) == 0:
                    compatible_messages = planned_messages
                if len(compatible_messages) == 0:
                    continue
                message_to_send = random.choice(compatible_messages)
                dispatch_request.time_last_dispatch = now
                dispatch_request.save()
                if bot is None:
                    bot = Bot(token=bot_token)
                failed = False
                try:
                    bot.send_message(
                        chat_id=group_preferences.group.telegram_id,
                        text=message_to_send.message
                        .replace('&nbsp;', ' ')
                        .replace('<br>', '')
                        .replace('<br >', '')
                        .replace('<br/>', '')
                        .replace('<br />', ''),
                        parse_mode=ParseMode.HTML,
                    )
                except:
                    traceback.print_exc()
                    failed = True
                if failed:
                    group_preferences.planned_message_fails += 1
                    if group_preferences.planned_message_fails >= 5:
                        group_preferences.planned_message_enabled = False
                    group_preferences.save()
                else:
                    if group_preferences.planned_message_fails > 0:
                        group_preferences.planned_message_fails = 0
                        group_preferences.save()


taskmodels.Task.objects.filter().delete()
taskmodels.CompletedTask.objects.filter().delete()
captcha_kicker(schedule=5)
dispatch_periodic_messages(schedule=30)
clean_logs(schedule=200)