import json
import os
import sys
import uuid
from itertools import cycle

import logging
import random
import string
import time
import requests
import hashlib

# from convert_msg_access_token import convert_to_msg_token
# from login import FBClient

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s %(module)s: %(message)s",
                    datefmt='%Y-%m-%d %H:%M:%S')
logger = logging.getLogger(__name__)

class TokenManager:
    TOKEN_MANAGER_API = "http://35.196.221.1:1001/api/db"

    @classmethod
    def get_token(cls):
        res = requests.get(cls.TOKEN_MANAGER_API, timeout=10).json()
        uid = res["uid"]
        access_token = res["access_token"]
        return uid, access_token

    @classmethod
    def push_token(cls, username, password, uid, access_token):
        res = requests.post(cls.TOKEN_MANAGER_API,
                            data={"username": username, "password": password, "uid": uid, "access_token": access_token},
                            timeout=10).json()
        return res["success"]

    @classmethod
    def set_token_dead(cls, uid):
        res = requests.patch(cls.TOKEN_MANAGER_API, data={"uid": uid, "dead": True}, timeout=10).json()
        return res["success"]

    @classmethod
    def set_token_limit(cls, uid):
        res = requests.patch(cls.TOKEN_MANAGER_API, data={"uid": uid, "synclimit": True}, timeout=10).json()
        return res["success"]


def calculate_signature(data, secret=None):
    api_secret = secret
    sig = ""
    for key in sorted(data.keys()):
        sig += "{0}={1}".format(key, data[key])
    data["sig"] = hashlib.md5((sig + api_secret).encode("utf-8")).hexdigest()
    return data["sig"]


def renew_connection():
    renew_ip()
    # if CheckpointChecker.is_consecutive_checkpoint():
    #     renew_ip()
    # else:
    #     CheckpointChecker.failed_reg()

class FBRegister:
    API_URL = "https://z-m-api.facebook.com/method/user.register"
    HEADERS = {
        "User-Agent": "[FBAN/FB4A;FBAV/175.0.0.40.97;]",
    }

    APP_ID = "350685531728"
    APP_SECRET = "62f8ce9f74b12f84c123cc23437a4a32"

    def __init__(self, email, password, first_name="", last_name="", gender="F", birthday="", proxy=None):
        self.email = email
        self.password = password
        if first_name:
            self.first_name = first_name
        else:
            self.first_name = "Huyen"
        if last_name:
            self.last_name = last_name
        else:
            self.last_name = "Le Thi"
        self.gender = gender
        if birthday:
            self.birthday = birthday
        else:
            self.birthday = "1997-07-06"
        self.session = requests.Session()
        if proxy:
            logger.info("Use proxy {}".format(proxy))
            self.session.proxies = {"https": proxy}
            self.session.verify = False

    @classmethod
    def send_zeroheader(cls, proxy=None):
        url = 'https://b-api.facebook.com/method/mobile.zeroHeaderRequest'
        headers = {
            'x-fb-friendly-name': 'fetchZeroHeaderRequest',
            'authorization': 'OAuth null'
        }
        data = {
            #'access_token': f'{cls.APP_ID}|{cls.APP_SECRET}',
            'carrier_mcc': '310',
            'carrier_mnc': '260',
            'client_country_code': 'US',
            'machine_id': "eZKiW2cRfI3_LfPmIn6r64H0",
            'device_id': str(uuid.uuid4()),
            'fb_api_caller_class': 'com.facebook.zero.service.ZeroTokenHandler',
            'fb_api_req_friendly_name': 'fetchZeroHeaderRequest',
            'force_refresh': 'false',
            'format': 'json',
            'header_usage': 'headers_cache_usage',
            'interface': 'wifi',
            'locale': 'en_US',
            'method': 'mobile.zeroHeaderRequest',
            'sim_mcc': '310',
            'sim_mnc': '270'
        }
        try:
            response = requests.post(url, data=data, headers=headers, proxies={"https": proxy}, timeout=7)
        except Exception as e:
            print(e)
        else:
            response = json.loads(response.text)
            if response.get("edid"):
                logger.info("Sent zeroHeader request {}".format(proxy or ""))
                return True
        return False

    def prepare_request_data(self):
        data = {"email": self.email, "firstname": self.first_name, "lastname": self.last_name, "gender": self.gender,
                "password": self.password, "birthday": self.birthday, "attempt_login": "true", "format": "json",
                "locale": "en_US", "method": "user.register",
                "fb_api_caller_class": "com.facebook.registration.fragment.RegistrationCreateAccountFragment",
                "api_key": "882a8490361da98702bf97a021ddc14d"}
        # data["client_country_code"] = "US"
        data["sig"] = calculate_signature(data, "62f8ce9f74b12f84c123cc23437a4a32")
        return data

    def execute(self):
        # self.send_zeroheader()
        request_data = self.prepare_request_data()
        try:
            response = self.session.post(self.API_URL, data=request_data, headers=self.HEADERS, timeout=20)
        except Exception:
            return None, None
        else:
            total_time = response.elapsed.total_seconds()
            response = json.loads(response.text)
        try:
            session_info = response["session_info"]
            uid, access_token = session_info["uid"], session_info["access_token"]
            logger.info("Registered in {}s - {} - UID: {}".format(total_time, self.email, uid))
            return uid, access_token
        except Exception as e:
            error_code = response.get("error_code")
            if error_code == 368:
                logger.info("Register service is current banned")
                renew_connection()
            elif error_code == 3107:
                logger.info("Invalid username {}".format(self.email))
            elif error_code == 3125:
                logger.info("Invalid phone {}".format(self.email))
            else:
                logger.info(response)
            return None, None


last_created = 0
fail_count = 0


class RandomFBRegister:
    MAIL_DOMAIN = "gmail.com"
    last_created = 0
    fail_count = 0

    @classmethod
    def check_consecutive_checkpoint(cls):
        logger.info("Fail count: {}".format(cls.fail_count))
        if round(time.time() - cls.last_created, 2) <= 10:
            if cls.fail_count >= 5:
                logger.info("Low token quality ...")
                renew_connection()
                cls.fail_count = 0
            else:
                cls.fail_count += 1
        else:
            cls.fail_count = 0

    @classmethod
    def create(cls, proxy=None):
        cls.check_consecutive_checkpoint()
        access_token = None
        while not access_token:
            username = ''.join(random.choice(string.ascii_lowercase) for x in range(11)) + "@" + cls.MAIL_DOMAIN
            # username = "038" + ''.join(random.choice(string.digits) for x in range(7))
            # username = "+1" + random.choice(["316", "769", "515", "228", "231", "385", "386", "231"]) + ''.join(
            #     random.choice(string.digits) for x in range(7))
            password = "fbtest123"
            uid, access_token = FBRegister(username, password, proxy=proxy).execute()
        cls.last_created = time.time()
        return uid, access_token


if __name__ == "__main__":
    uid, access_token = RandomFBRegister.create()
    TokenManager.push_token("teamtree", "fbtest123", uid, access_token)
    print(uid,access_token)