import random
import threading
import time
from http.cookies import SimpleCookie

import pika

from db.mongo_manager import MONGO_STORE_MANAGER
from models.contact_pojo import ContactPojo
from workers.captcha_result_getter import CaptchaResultGetter, HERMES_REGISTER
from workers.sender import Sender

QUEUE_HOST = "appointment.lpaconsulting.fr"
REQUEST_DATA_QUEUE = 'REQUEST_DATA'
credentials = pika.PlainCredentials('appointment', 'ZyuhJZ2xEYWhElhpJjy7YEpZGZwNYJz2fHIu')


def is_already_sent(contact: ContactPojo) -> bool:
    already_sent_contacts = MONGO_STORE_MANAGER.get_all_successful_items_for_day()
    for required_contact in already_sent_contacts:
        if contact.mail == required_contact.email:
            return True
    return False


def filter_contacts(_contact_list: list) -> list:
    already_sent_contacts = MONGO_STORE_MANAGER.get_all_successful_items_for_day()
    _contact_list_to_book = []
    for contact in _contact_list:
        _to_add = True
        for booked in already_sent_contacts:
            if contact.mail == booked.email:
                _to_add = False
        if _to_add:
            _contact_list_to_book.append(contact)

    return _contact_list_to_book


def get_valid_csrf() -> str:
    captchaResultGetter = CaptchaResultGetter()
    _valid_cookie = captchaResultGetter.get_valid_cookie()
    # while _valid_cookie is None:
    #     _valid_cookie = captchaResultGetter.get_valid_cookie()
    new_csrf = None
    while new_csrf is None:
        valid_cookie = None
        if _valid_cookie is not None:
            simple_cookie = SimpleCookie()
            simple_cookie.load(_valid_cookie)
            new_cookies = {k: v.value for k, v in simple_cookie.items()}
            new_coolies_str = ""
            for key in new_cookies:
                print(key)
                new_coolies_str = new_coolies_str + key + "=" + new_cookies[key] + ";"
            print(new_coolies_str)
            valid_cookie = new_coolies_str + "app=eyJmbGFzaCI6e30sImNhY2hlZmxhc2giOltdLCJjc3JmU2VjcmV0IjoiYnRodHNYU1lvdnl4RzVGakpGRDZsQ0JtIn0=;policy=accepted;lang=fr;"
        print(valid_cookie)
        new_csrf = captchaResultGetter.get_csrf(valid_cookie)
        if new_csrf is None:
            _valid_cookie = None
            while _valid_cookie is None:
                _valid_cookie = captchaResultGetter.get_valid_cookie()
        time.sleep(2)
    return new_csrf


class Receiver(threading.Thread):
    def __init__(self, sub_contact_list: list):
        self.connection = None
        self.channel = None
        self.valid_csrf = None
        self.contact_list = sub_contact_list

    def set_up_connection(self):
        self.connection = pika.BlockingConnection(
            pika.ConnectionParameters(host=QUEUE_HOST, port=5672, credentials=credentials))
        self.channel = self.connection.channel()

    def listen_to_queue(self, callback):
        self.channel.basic_qos(prefetch_count=1)
        self.channel.basic_consume(queue=REQUEST_DATA_QUEUE, auto_ack=False, on_message_callback=callback)
        self.channel.start_consuming()

    def on_message(self, ch, method, properties, body):
        print(f" [x] Received {body}")
        sender = Sender(body.decode("UTF-8"))
        self.contact_list = filter_contacts(self.contact_list)
        # remove already booked contacts
        random.shuffle(self.contact_list)
        if len(self.contact_list) > 0:
            print("contact number is {}".format(len(self.contact_list)))
            for con in self.contact_list:
                # if not is_already_sent(con):
                print(con.mail)
                # time.sleep(random.randint(1, 5))
                if self.valid_csrf is None:
                    self.valid_csrf = get_valid_csrf()
                can_continue = sender.send_request(HERMES_REGISTER, con, csrf=self.valid_csrf)
                if not can_continue:
                    print("cannot continue, valid_csrf is " + self.valid_csrf)
                    break
                else:
                    print("can continue, will reset valid_csrf")
                    self.valid_csrf = None
                # else:
                #     print(con.mail + "--> skip")
            ch.basic_ack(delivery_tag=method.delivery_tag)
        else:
            print("empty list")

    def run(self):
        print(threading.currentThread().name + " starts")
        self.set_up_connection()
        self.listen_to_queue(self.on_message)
        self.channel.start_consuming()
# if __name__ == '__main__':
#     receiver = Receiver()
#     receiver.set_up_connection()
#     receiver.listen_to_queue(on_message)