import datetime
import json
import random
import time
from http.cookies import SimpleCookie
from models.contact_pojo import ContactPojo
import requests

from db.mongo_manager import MONGO_STORE_MANAGER
from models.ReserveResultPojo import ReserveResultPojo, PublishType
from models.jsdata_pojo import JsDataPojo
from models.result_pojo import RequestResult
from queue_message.CookiesPublisher import CookiesPublisher
from utils.address_ip import get_address_ip


class Sender:

    def __init__(self, cookie_str, cookiesPublisher: CookiesPublisher, received_dict, proxy_to_use, logger):
        self.store_type = "random"
        self.cookie = SimpleCookie()
        self.cookiesPublisher = cookiesPublisher
        # self.cookie_str = 'datadome=~pxdHFAvsQl2rvDrTzhPgCHxu~4TBcePTTE~Cy8Rgol6oMRc11gA02VRp0Z3uEDUszCjacubNu7vbfQCh27gz8RC10u_325pt_gsMmJh1ScGvOofVJiVAbEKvSEUjd82;policy=accepted;app.sig=PhjmDkq_dI49pADppDNKxpLe_G4;app=eyJmbGFzaCI6e30sImNhY2hlZmxhc2giOltdLCJjc3JmU2VjcmV0IjoiYnRodHNYU1lvdnl4RzVGakpGRDZsQ0JtIn0=;lang=fr;'
        self.cookie_str = cookie_str
        self.logger = logger
        self._csrf = None
        self.received_dict = received_dict
        self.proxy_to_use = proxy_to_use
        self.cookie.load(self.cookie_str)

    def publish_message_to_queue(self, contact: ContactPojo, status: PublishType, url: str, store_type: str):
        # create the message
        if url == "https://rendezvousparis.hermes.com/client/welcome":
            return
        id = url.split("/")[-1]
        result = ReserveResultPojo(type=status, phone=contact.phone, message=status.value, url=url,
                                   firstName=contact.first_name, lastName=contact.last_name, email=contact.mail,
                                   passport=contact.passport, ccid=contact.ccid)
        result.ua = contact.ua
        result.current_ip = contact.current_ip
        if "oxylabs" in self.proxy_to_use["http"]:
            if "mob" in self.proxy_to_use["http"]:
                result.proxy = "oxylabs_mob"
            else:
                result.proxy = "oxylabs_res"
        else:
            result.proxy = "data_impulse"
        result.id = id
        result.store_type = store_type
        result.created_at = time.strftime("%H:%M:%S", time.localtime())
        collection_name = str(datetime.date.today())
        MONGO_STORE_MANAGER.insert_reserve_result(collection_name=collection_name, reserve=result)

    def send_request_for_list(self, contact_list: list):
        pass

    def get_csrf(self):
        pass

    def send_request(self, url, js_data: JsDataPojo, contact: ContactPojo, csrf: str = None) -> RequestResult:
        if csrf is None:
            if self._csrf is None:
                _csrf = '8Bs2dBwb-nHONOzo9Tei2CcMZglEfsRqUz8E'
            else:
                _csrf = self._csrf
        else:
            self._csrf = csrf
            _csrf = csrf
        # 默认为空，也就是随机
        _selected_store = ''
        if contact.store is not None and contact.store != "random":
            _selected_store = contact.store
        self.logger.info("store is:{}".format(_selected_store))
        headers = {'Content-Type': 'application/x-www-form-urlencoded',
                   'User-Agent': js_data.ua,
                   'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
                   'Cookie': self.cookie_str, 'Referer': 'https://rendezvousparis.hermes.com/client/register',
                   'Sec-Fetch-Mode': 'navigate',
                   'Sec-Fetch-Dest': 'document',
                   'Accept-Language': 'fr-FR,fr;q=0.6'}
        data = {'check': '', '_csrf': _csrf, 'prefer': _selected_store,
                'surname': contact.last_name.capitalize(), 'name': contact.first_name.capitalize(),
                'phone_country': "FR", 'phone_number': "+33 " + contact.phone, 'email': contact.mail,
                'passport_id': contact.passport, 'processing': 'on', 'cgu': 'on'}
        self.logger.info(data)
        self.logger.info("try to request for mail:{}".format(contact.mail))
        print("send request with cookie:{}".format(self.cookie_str))
        try:
            proxy_to_use = self.proxy_to_use
            # print(proxy_to_use)
            response = requests.post(url=url, proxies=proxy_to_use, verify=False, headers=headers, data=data,
                                     timeout=15)
            self.logger.info(response.status_code)
            if response.status_code == 200:
                # add to mongodb
                self.logger.info(response.text)
                self.logger.info("{}:{}".format(contact.mail, response.url))
                contact.ua = js_data.ua
                contact.current_ip = get_address_ip(proxy_to_use=proxy_to_use)
                self.publish_message_to_queue(contact, status=PublishType.SUCCESS, url=response.url,
                                              store_type=_selected_store)
                cookies_to_set = response.headers['set-cookie']
                self.cookie.load(cookies_to_set)
                new_cookies = {k: v.value for k, v in self.cookie.items()}
                new_coolies_str = ""
                for key in new_cookies:
                    new_coolies_str = new_coolies_str + key + "=" + new_cookies[key] + ";"
                self.logger.info("will publish to queue {}".format(new_coolies_str))
                # upload the cookie to queue
                self.received_dict['cookiesStr'] = new_coolies_str
                self.logger.info("body in json:{}".format(json.dumps(self.received_dict)))
                self.cookiesPublisher.publish_body(json.dumps(self.received_dict))
                # self.cookie_str = new_coolies_str
                self.logger.info("successful request, mail:{}".format(contact.mail))
                return RequestResult.SUCCESS
            else:
                print(response.text)
                if response.status_code == 403:
                    # try to load seesion
                    # session = HTMLSession()
                    self.logger.info("blocked by hermes, mail:{}".format(contact.mail))
                    return RequestResult.BLOCKED
                return RequestResult.BLOCKED
        except Exception as Error:
            print(Error)
            return RequestResult.PROXY_ERROR