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

import pika

from queue_message.CookiesPublisher import CookiesPublisher, QUEUE_HOST, credentials, REQUEST_DATA_QUEUE, \
    REQUEST_DATA_QUEUE_TEST
from workers.captcha_result_getter import CaptchaResultGetter
from workers.proxies_constants import PROXY_LIST_FR

DVM_LIST = [2, 3, 4, 6]


class CookiesGenerator(threading.Thread):
    def __init__(self, proxy_to_use_list: list, cookiesPublisher: CookiesPublisher):
        super().__init__()
        self.connection = None
        self.cookiesPublisher = cookiesPublisher
        self.channel = None
        self.valid_csrf = None
        self.proxy_to_use_list = proxy_to_use_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 message_count(self):
        return self.channel.queue_declare(queue=REQUEST_DATA_QUEUE, durable=True).method.message_count

    def on_message(self, ch, method, properties, body):
        print(f" [x] Received {body}")
        _cached_message_count = self.cookiesPublisher.message_count()
        _valid_message_count = self.message_count()
        print("message count in cache is {}".format(_cached_message_count))
        print("message count in current queue is {}".format(_valid_message_count))

        #     generate 10 cookies to new_queue
        captchaResultGetter = CaptchaResultGetter()
        _cookies_count = random.randint(8, 10)
        _received_cookies = body.decode("UTF-8")
        dvm = random.choice(DVM_LIST)
        hc = random.choice(DVM_LIST)
        if _cached_message_count < 10 and _valid_message_count > 40:
            _proxy_to_use = random.choice(self.proxy_to_use_list)
            for i in range(1, _cookies_count):
                # new_cookie = captchaResultGetter.get_valid_ch_cookie(proxy_to_use=_proxy_to_use, dvm=dvm, hc=hc)
                _app_sig = get_app_and_app_sig(_received_cookies)
                # if new_cookie is not None and _app_sig is not None:
                #     new_cookie = _app_sig + "policy=accepted;lang=fr;" + new_cookie
                #     new_cookie = new_cookie.replace("Domain=.hermes.com;", "").replace("Path=/;", "").replace(
                #         "Secure; SameSite=None", "").replace("Max-Age=31536000;", "").replace(" ", "")
                #     print("new_cookie is " + new_cookie)
                #     _received_cookies = new_cookie
                #     self.cookiesPublisher.publish_body(new_cookie)
                new_cookie = captchaResultGetter.get_valid_cookie(proxy_to_use=_proxy_to_use,
                                                                  old_valid_cookie=_received_cookies, dvm=dvm,
                                                                  hc=hc)
                if new_cookie is not None and _app_sig is not None:
                    new_cookie = _app_sig + "policy=accepted;lang=fr;" + new_cookie
                    new_cookie = new_cookie.replace("Domain=.hermes.com;", "").replace("Path=/;", "").replace(
                        "Secure; SameSite=None", "").replace("Max-Age=31536000;", "").replace(" ", "")
                    _received_cookies = new_cookie
                    self.cookiesPublisher.publish_body(new_cookie)
            ch.basic_ack(delivery_tag=method.delivery_tag)
        else:
            time.sleep(30)
            ch.basic_reject(delivery_tag=method.delivery_tag, requeue=True)

    def run(self):
        print(threading.currentThread().name + " starts")
        self.set_up_connection()
        self.listen_to_queue(self.on_message)
        self.channel.start_consuming()


def get_app_and_app_sig(cookies: str):
    _local_cookies = SimpleCookie()
    _local_cookies.load(cookies)
    new_coolies_str = ""
    new_cookies = {k: v.value for k, v in _local_cookies.items()}
    for key in _local_cookies:
        if key == "app" or key == "app.sig":
            new_coolies_str = new_coolies_str + key + "=" + new_cookies[key] + ";"
    return new_coolies_str


if __name__ == '__main__':
    cookiesPublisher = CookiesPublisher(queue_name=REQUEST_DATA_QUEUE_TEST)
    cookiesPublisher.set_up_connection()
    cookieGenerator = CookiesGenerator(proxy_to_use_list=PROXY_LIST_FR, cookiesPublisher=cookiesPublisher)
    cookieGenerator.run()