#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/3/30 3:57 下午
# @Author  : Lemon
# @File    : state.py
# @Software: PyCharm
import base64
import hashlib
import json
import linecache
import random
import re
import threading
import time
import uuid
from requests.adapters import HTTPAdapter
import curlify
import requests
from fbchat import FBchatUserError, _exception, _util
from fbchat._state import State, is_home
from furl import furl
from requests import Session as Session_

from bin.start import BASE_DIR
from lib import common, graph
from utils import parse_html, encpass
from utils.cache import cache, redis
from utils.encpass import dict_cookies_to_str
from utils.parse_html import show_login_is_click


class Session(Session_):

    def set_logout_callback(self, logout):
        self.logout_call = logout

    def _match_redirect_(self, content):
        try:
            url = re.search(r'"ServerRedirect",".*?",\[.*?\],\["(.*?)"', content).group(1)
        except:
            url = ''
        return url

    def request(self, *args, **kwargs):
        try:
            # res = super().request(*args, **kwargs, verify=False)
            res = super().request(*args, **kwargs, hooks=dict(response=[self.hook_cookies]))
            content = res.text
            set_cookie = res.headers.get('Set-Cookie', None)
            if 'checkpoint' in res.url:
                params, content = self.verification_init(**kwargs)
                if '人机验证' in content:
                    raise FBchatUserError('账号被封锁:' + content)
                if '选择安全验证' in content:
                    way_list, content, params = self.get_verification_method(content, params)  # 获取解锁方法
                    email = self.user_obj.email
                    cache.set(key=f'{email}:verification_method', value=way_list)
                if '双重验证' in content and self.user_obj.approvals_code is not None:
                    result, res = self.approvals_code_login(content, params)
                    if result:
                        return res  # 安全码登录成功
                    else:
                        raise FBchatUserError('安全码登录失败:安全码无效')
                raise FBchatUserError('账号被封锁:' + content)
            elif 'ServerRedirect' in content and self._match_redirect_(content) == '\\/checkpoint\\/block\\/':
                raise FBchatUserError('账号被封锁')
            elif 'graph.facebook.com' in res.url and 'OAuthException' in res.text:
                error_code = res.json()['error']['code']
                if error_code == 190:
                    raise FBchatUserError('号码掉线了')
                elif error_code == 803:
                    # Cannot query users by their username (Ranjithema143)
                    pass
                else:
                    print(res.text)
            elif 'api.facebook.com/method/fql.multiquery' in res.url and content and 'error_code' in content:
                result = json.loads(content)
                if result['error_code'] == 190:
                    raise FBchatUserError(f'号码掉线了:{result["error_msg"]}')
            elif set_cookie and 'c_user=deleted' in set_cookie:
                raise FBchatUserError('号码掉线了')
            return res
        except FBchatUserError:
            hasattr(self, 'logout_call') and self.logout_call()
            raise

    def get_curl(self, response, *args, **kwargs):
        print(print(curlify.to_curl(response.request)))

    def hook_cookies(self, response, *args, **kwargs):
        """
        request-hook
        """
        try:
            new_cookies = dict_cookies_to_str(response.request._cookies.get_dict())
            if 'c_user' in new_cookies:
                key = f'cookies:{response.request._cookies.get_dict()["c_user"]}'
                if cache.has(key):
                    obj = cache.get(key)
                    if new_cookies == obj.cookie:
                        return
                    else:
                        # cookies有变化
                        obj.set(cookie=new_cookies)
                        redis_save = json.dumps(
                            {"fbid": obj.fbid, "user_agent": obj.user_agent, "cookie": new_cookies, 'proxy': obj.proxy,
                             'token': obj.token})
                        threading.Thread(target=redis.set, kwargs={'name': obj.email, 'value': redis_save}).start()
                        threading.Thread(target=redis.set, kwargs={'name': obj.fbid, 'value': redis_save}).start()
                        if redis.exists(f'collect:{obj.user_mark}:{obj.fbid}'):
                            threading.Thread(target=redis.set,
                                             kwargs={'name': f'collect:{obj.fbid}',
                                                     'value': redis_save}).start()
                        print('保存redis成功', redis_save)
        except BaseException as e:
            print('保存redis失败', e)
            pass

    def verification_init(self, **kwargs):
        """
        获取解封方式 所需要参数
        """
        res = super().request('GET', 'https://zh-cn.facebook.com/checkpoint/?next')
        content = parse_html.checkpoint_text(res.text)
        args = parse_html.get_lock_init(res.text)
        try:
            fb_dtsg_ag = args[0]
            nh = args[1]
            params = {
                'modules': 'FormSubmit',
                "dpr": 2,
                "fb_dtsg_ag": fb_dtsg_ag,
                "jazoest": int(kwargs['data']['jazoest']),
                "nh": nh,
                "lsd": kwargs['data']['lsd']
            }
            return params, content
        except:
            return {}, content

    def get_verification_method(self, content, params):
        """
        获取解封方法
        """
        async_params = params.copy()
        async_params.pop('modules', None)
        async_params.pop('dpr', None)
        async_params.pop('lsd', None)
        async_params['fb_dtsg'] = params['fb_dtsg_ag']
        async_params.pop('fb_dtsg_ag', None)
        async_params['submit[Continue]'] = '继续'
        super().request('POST', 'https://www.facebook.com/checkpoint/async?next', data=async_params)
        res = super().request('GET', 'https://zh-cn.facebook.com/checkpoint/?next')
        way_list = parse_html.get_verification_method(res.text)
        return way_list, content, params  # 解封方式在里面

    def approvals_code_login(self, content, params):
        """
        安全码登录
        """
        params.pop('modules', None)
        params.pop('dpr', None)
        params.pop('lsd', None)
        params['fb_dtsg'] = params['fb_dtsg_ag']
        params.pop('fb_dtsg_ag', None)
        # self.user_obj.approvals_code = ['02541695', '05689965', '16576325']
        for code in self.user_obj.approvals_code:
            loop = True
            while loop:
                res = self.check_approvals_code(code, content, params)
                if res.url == "https://www.facebook.com/" or res.url == 'https://www.facebook.com/?sk=welcome':
                    return True, res
                if res is None:
                    content = '你要求 Facebook 在任何用户通过陌生设备或浏览器登录时询问 6 位登录验证码。'
                    break
                content = parse_html.checkpoint_text(res.text)
                if '你要求 Facebook 在任何用户通过陌生设备或浏览器登录时询问 6 位登录验证码。' in content or content == "":
                    print('安全码失效', self.user_obj.email, code)
                    content = '你要求 Facebook 在任何用户通过陌生设备或浏览器登录时询问 6 位登录验证码。'
                    break
        return False, res

    def check_approvals_code(self, code, content, params):
        """
        安全码登录方法
        """
        if '你要求 Facebook 在任何用户通过陌生设备或浏览器登录时询问 6 位登录验证码。' in content:
            # 提交安全码
            approvals_code_params = params.copy()
            approvals_code_params['approvals_code'] = code
            approvals_code_params['submit[Continue]'] = '继续'
            approvals_code_params['no_fido'] = True
            res = super().request('POST', 'https://zh-cn.facebook.com/checkpoint/?next',
                                  data=approvals_code_params)
            return res
        if '保存浏览器' in content:
            save_device_params = params.copy()
            save_device_params['submit[Continue]'] = '继续'
            save_device_params['name_action_selected'] = 'save_device'
            res = super().request('POST', 'https://zh-cn.facebook.com/checkpoint/?next',
                                  data=save_device_params)
            if 'legal_consent' in res.url:
                print("注意安全码登录未知情况，请尽快把此号交给维护人员，补充加入安全码登录逻辑中！！！！！！！！！", res.url)
                desktop_params = params.copy()
                desktop_params['dpr'] = 2
                # desktop_params['__a'] = 1
                # desktop_params[
                #     '__dyn'] = '7xe6Fo4OQ3S3mbG2KnFwn8eFU98nwgU6C7UW3q327Eiw8OdwJx61Mwaa4E9ohwem0nCq1ewcG0KEswaq2210wEwt838wGwvbAy85iawnEfU7e2l0Fwwwi831wnEfo2IwKw9O0RE5a1qw8W1uwbG'
                # desktop_params['__pc'] = 'PHASED:DEFAULT'
                # desktop_params['__ccg'] = 'UNKNOWN'
                # desktop_params['__rev'] = 1003142757
                # desktop_params['__comet_req'] = 0
                # desktop_params['__beoa'] = 0
                desktop_params['_user'] = res.request._cookies.get('c_user')
                url = 'https://www.facebook.com/gdpr/consent/desktop_logging/?event=click&consent_product=consent&consent_action_type=accept&consent_step=0&consent_type=16&consent_region=0&consent_mode=5&entry_product=cg_block'
                res = super().request('POST', url, data=desktop_params)
            return res
        if '审核近期登录记录' in content:
            if '是我本人' in content:
                check_params = params.copy()
                check_params['submit[This was me]'] = '是我本人'
                res = super().request('POST', 'https://zh-cn.facebook.com/checkpoint/?next',
                                      data=check_params)
                return res
            else:
                check_params = params.copy()
                check_params['submit[Continue]'] = '继续'
                res = super().request('POST', 'https://zh-cn.facebook.com/checkpoint/?next',
                                      data=check_params)
                return res
        if '大概登录时间' in content:
            check_params = params.copy()
            check_params['submit[This was me]'] = '是我本人'
            res = super().request('POST', 'https://zh-cn.facebook.com/checkpoint/?next',
                                  data=check_params)
            return res
        else:
            print(f'安全码登录未知情况:{content}')
            return None


class PCState(State):

    @classmethod
    def random_useragent(self):
        line = linecache.getline('data/pc_chrome_ua.txt', random.randint(1, 9797))
        return line.strip() or random.choice(_util.USER_AGENTS)

    @classmethod
    def session_factory(cls, user_agent=None):
        def is_mobile(user_agent):
            return re.search(r'(iPad).*OS\s([\d_]+)|(Android)\s+([\d.]+)|(iPhone\sOS)\s([\d_]+)',
                             user_agent) is not None

        session = Session()
        header = '''accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
        accept-language: en-US;q=1,en;q=0.9,zh-TW;q=0.8
        cache-control: no-cache
        pragma: no-cache
        sec-fetch-dest: document
        sec-fetch-mode: navigate
        sec-fetch-site: same-origin
        sec-fetch-user: ?1
        upgrade-insecure-requests: 1
        user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.105 Safari/537.36
        viewport-width: 1440'''
        session.headers.update({k: v for k, v in [h.strip().split(': ', maxsplit=1) for h in header.split('\n') if h]})
        session.headers["User-Agent"] = user_agent or cls.random_useragent()
        if is_mobile(session.headers["User-Agent"]):
            session.headers["Referer"] = "https://m.facebook.com/"
            setattr(session, 'mobile', True)
        else:
            session.headers["Referer"] = "https://www.facebook.com/"
            setattr(session, 'mobile', False)
        # 下面解决 WARNING:urllib3.connectionpool:Connection pool is full, discarding connection: www.facebook.com
        adapter = requests.adapters.HTTPAdapter(pool_connections=20, pool_maxsize=20)
        session.mount('https://', adapter)
        return session

    def android_session_factory(cls, friendlyName, user_agent, token, proxy=None, Host='graph.facebook.com',
                                header_list=[]):
        session = Session()
        header = '''X-FB-Connection-Type: WIFI
        X-FB-Connection-Quality: EXCELLENT
        User-Agent: [FBAN/FB4A;FBAV/294.0.0.35.118;FBBV/252996732;FBDM/{density=2.625,width=1080,height=1920};FBLC/en_US;FBRV/0;FBCR/;FBMF/Xiaomi;FBBD/Xiaomi;FBPN/com.facebook.katana;FBDV/MI 6;FBSV/9;FBOP/1;FBCA/arm64-v8a:;]
        Content-Encoding: gzip
        Content-Type: application/x-www-form-urlencoded
        X-Tigon-Is-Retry: False
        Accept-Encoding: gzip, deflate
        X-FB-HTTP-Engine: Liger
        X-FB-Client-IP: True
        Host: graph.facebook.com'''
        session.headers.update({k: v for k, v in [h.strip().split(': ', maxsplit=1) for h in header.split('\n') if h]})
        session.headers["User-Agent"] = user_agent
        session.headers.update({'X-FB-Friendly-Name': f'{friendlyName}'})
        session.headers.update({'Authorization': f'OAuth {token}'})
        session.headers.update({'Host': Host})
        for header in header_list:
            session.headers.update(header)
        if proxy:
            proxy = common.frombase64(proxy)
            short_proxy = common.format_proxies(proxy, 'requests')
            long_proxy = common.format_proxies(proxy, 'sock')
            print('使用代理:', proxy)
            setattr(session, '_args', {'sock': long_proxy})
            session.proxies.update(short_proxy)
        # 下面解决 WARNING:urllib3.connectionpool:Connection pool is full, discarding connection: www.facebook.com
        adapter = requests.adapters.HTTPAdapter(pool_connections=100, pool_maxsize=100)
        session.mount('https://', adapter)
        return session

    @classmethod
    def cookie_to_dict(cls, cookie: str):
        """
        把文本cookie转化为dict
        """
        ck_list = [k.split('=') for k in cookie.split('; ')]
        ck_dict = {k[0]: k[1] for k in ck_list}
        return ck_dict

    @classmethod
    def login2(cls, user_obj, proxy=None):
        session = cls.session_factory(user_agent=user_obj.user_agent)
        session.user_obj = user_obj
        if proxy:
            short_proxy = common.format_proxies(proxy, 'requests')
            long_proxy = common.format_proxies(proxy, 'sock')
            print(user_obj.email, '使用代理:', proxy)
            setattr(session, '_args', {'sock': long_proxy})
            print('长连接代理', long_proxy)
            session.proxies.update(short_proxy)
        if user_obj.is_second:
            cookies = cls.cookie_to_dict(user_obj.cookie)
            cookies.pop('c_user', None)
            cookies.pop('fr', None)
            cookies.pop('spin', None)
            cookies.pop('xs', None)
            cookies.update({'locale': 'en_US'})
            session.cookies.update(cookies)
        text = session.get("https://www.facebook.com/").text
        pubkey, keyid, privacy_mutation_token = parse_html.get_publickey_id(text)
        datr = parse_html.get_datr(text)
        soup = parse_html.find_input_fields_with_pc(text)
        data = dict((elem["name"], elem["value"])
                    for elem in soup
                    if elem.has_attr("value") and elem.has_attr("name"))
        if user_obj.is_second and show_login_is_click(text, user_obj.fbid):
            # 二次登录
            print('二次登录1', user_obj.fbid)
            data.pop('login_source')
            data.update({
                'uid': user_obj.fbid,
                'source': 'side_by_side',
                'next': ''
            })
            r = session.post('https://www.facebook.com/login/device-based/login/', data=data)
            if 'login/?cuid=' in r.url:
                print('二次登录2', user_obj.fbid)
                f = furl(r.url)
                cuid = f.args['cuid']
                data.pop('uid', None)
                data.pop('source', None)
                data.pop('next', None)
                data.update({
                    'cuid': cuid,
                    'cred_type': 137,
                    'next': '',
                    'persistent': '',
                    'login_source': 'device_based_login',
                    'encpass': encpass.pc_encrypt_online(user_obj.password, keyid, pubkey)
                })
                r = session.post('https://www.facebook.com/login/device-based/regular/login/', data=data)
        else:
            # 常规帐号密码登录
            if not user_obj.is_second:
                print('常规登录', user_obj.email)
                session.cookies.set('wd', '1440x756')
                session.cookies.set('dpr', '2')
                session.cookies.set('datr', datr)  # 登录风控点
            conset_data = data.copy()
            conset_data.pop('login_source')
            conset_data['accept_consent'] = False
            conset_data['dpr'] = 2
            # 新登录接口
            data.update({
                'email': user_obj.email,
                'encpass': encpass.pc_encrypt_online(user_obj.password, keyid, pubkey)
            })
            if user_obj.is_second:
                session.cookies.update(cls.cookie_to_dict(user_obj.cookie))
            r = session.post(f'https://www.facebook.com/login/?privacy_mutation_token={privacy_mutation_token}',
                             data=data)
            # 新登录接口
        setCookie = r.headers.get('Set-Cookie') or ''

        if 'recover/initiate' in r.text and not user_obj.is_second:
            raise _exception.FBchatUserError('密码错误')

        if 'checkpoint' in setCookie or 'checkpoint/' in r.text:
            r = session.get('https://zh-cn.facebook.com/checkpoint/?next')
            raise _exception.FBchatUserError('账号被封锁:' + parse_html.checkpoint_text(r.text))

        if '/gdpr/consent/' in r.url:
            cls._gdpr_accept(r, session)

        if 'device-based' in r.url and 'c_user' in setCookie:
            r.url = 'https://www.facebook.com/'

        if 'c_user' in setCookie:
            r.url = 'https://www.facebook.com/'
        if 'mobileprotection' in r.url:
            r.url = 'https://www.facebook.com/'
        if is_home(r.url):
            # wss = re.findall(r'endpoint:"(.*?)"}', r.text)[0]
            # cache.set(f'{user_obj.email}:wss', wss)
            return cls.from_session(session=session)
        else:
            raise _exception.FBchatUserError(
                "Login failed. Check email/password. "
                "(Failed on url: {})".format(r.url)
            )

    @classmethod
    def _gdpr_accept(cls, r, session):
        rec = re.compile(r'\["DTSGInitData",\[\],(\{.*?\}),\d+\]')
        initdata = rec.search(r.text).group(1)
        initdata = json.loads(initdata)
        fb_dtsg = initdata['token']
        # fb_dtsg_ag = initdata['async_get_token']
        jazoest = str(random.randint(20000, 30000))
        post_data = {
            '__user': session.cookies.get_dict().get('c_user'),
            '__a': 1,
            '__req': 'a',
            '__beoa': 0,
            '__pc': 'PHASED:DEFAULT',
            'dpr': '2',
            'fb_dtsg': fb_dtsg,
            'jazoest': jazoest,
        }
        try:
            accept_url = 'https://www.facebook.com/gdpr/consent/desktop_logging/?event=click&consent_product=consent&consent_action_type=accept&consent_step=0&consent_type=16&consent_region=0&entry_product=cg_block&consent_mode=5'
            rsp = session.post(accept_url, data=post_data)
        except:
            pass

        try:
            post_data['__req'] = 'b'
            accept_url = 'https://www.facebook.com/ajax/gdpr/consent/?consent_state=2&consent_type=16&is_shortform=true&consent_region=0&entry_product=cg_block'
            rsp = session.post(accept_url, data=post_data)
        except:
            pass

        try:
            post_data['__req'] = 'c'
            accept_url = 'https://www.facebook.com/gdpr/consent/desktop_logging/?event=click&consent_product=consent&consent_action_type=accept&consent_step=0&consent_type=16&consent_region=0&entry_product=cg_block&consent_mode=5'
            rsp = session.post(accept_url, data=post_data)
        except:
            pass

        try:
            post_data['__req'] = 'd'
            accept_url = 'https://www.facebook.com/gdpr/consent/desktop_logging/?event=impression&consent_product=consent_end&consent_step=999&consent_region=0&entry_product=cg_block&consent_mode=5'
            rsp = session.post(accept_url, data=post_data)
        except:
            pass

        try:
            post_data['__req'] = 'e'
            accept_url = 'https://www.facebook.com/gdpr/consent/desktop_logging/?event=click&consent_product=consent_end&consent_action_type=end_consent_flow&consent_step=999&consent_region=0&entry_product=cg_block&consent_mode=5'
            rsp = session.post(accept_url, data=post_data)
        except:
            pass

    def is_logged_in(self):
        if hasattr(self, '_online') and getattr(self, '_online'):
            return True
        url = "https://www.facebook.com/login.php?login_attempt=1"
        r = self._session.get(url, allow_redirects=False)
        bool = "Location" in r.headers and is_home(r.headers["Location"])
        if bool == False:
            print('账号未登录，前往登录！')
        else:
            setattr(self, '_online', True)
        return bool

    @classmethod
    def from_cookies(cls, cookies, user_agent=None, proxy=None):
        session = cls.session_factory(user_agent=user_agent)
        session.cookies = requests.cookies.merge_cookies(session.cookies, cookies)
        if proxy:
            short_proxy = common.format_proxies(proxy, 'requests')
            long_proxy = common.format_proxies(proxy, 'sock')
            setattr(session, '_args', {'sock': long_proxy})
            session.proxies.update(short_proxy)
        return cls.from_session(session=session)

    @classmethod
    def from_session(cls, session):
        def get_user_id(session):
            rtn = session.cookies.get_dict().get("c_user")
            if rtn is None:
                raise _exception.FBchatException("Could not find user id")
            return str(rtn)

        user_id = get_user_id(session)
        for _ in range(2):
            try:
                r = session.get(_util.prefix_url("/"), timeout=30)
            except (requests.exceptions.Timeout,
                    requests.exceptions.SSLError):
                print('超时重试')
                continue
            else:
                break
        try:
            b = parse_html.show_home_page(r.text)
            logout_menu = b.find('div', id='logoutMenu') or b.find('a', attrs={'aria-current': 'page',
                                                                               'aria-label': 'Home'})
            language = b.find('html').get('lang', None)
        except:
            raise Exception("网络错误")
        is_online = logout_menu is not None
        if is_online:
            id, name, url, image = user_id, '', '', ''
        else:
            id = name = url = image = None
            if b.find('div', id='checkpointBottomBar'):
                raise _exception.FBchatUserError('账号被封锁')

        fb_dtsg = None
        fb_dtsg_ag = None
        jazoest = None
        revision = random.randint(10, 200)
        try:
            rec = re.compile(r'\["DTSGInitData",\[\],(\{.*?\}),\d+\]')
            initdata = rec.search(r.text).group(1)
            initdata = json.loads(initdata)
            fb_dtsg = initdata['token']
            fb_dtsg_ag = initdata['async_get_token']
        except:
            pass
        try:
            revision = int(r.text.split('"client_revision":', 1)[1].split(",", 1)[0])
        except:
            pass
        try:
            jazoest = re.findall(r'jazoest=(\d+)"', r.text)[0]
        except:
            pass

        logout_h = None
        self = cls(
            user_id=user_id,
            fb_dtsg=fb_dtsg,
            revision=revision,
            session=session,
            logout_h=logout_h,
            counter=0,
        )

        self.id = id
        self.name = name
        self.page_url = url
        self.imageurl = image
        self._online = is_online
        self.fb_dtsg_ag = fb_dtsg_ag
        self.jazoest = jazoest
        self.language = language
        self.retry_count = 0

        return self

    def get_mobile_token(self, user):
        return None, None, None, None, None, None, None
        # with open(BASE_DIR + "/data/envJson.json", mode='r', encoding='utf-8') as f:
        #     env_json = f.read()
        # env_json = json.loads(env_json)
        # username = self.user_id
        # index = int(username[-2:])
        # device = env_json[index]
        # proxyInfo = dict()
        # makeProxy = True
        # if user.proxy is None:
        #     with open('HOST', 'r+') as f:
        #         HOST = f.read()
        #     proxy = {'host': HOST, 'pass': '', 'port': '59394', 'user': '', 'type': 'http'}
        # else:
        #     proxy = json.loads(base64.b64decode(user.proxy.encode('utf-8')).decode())
        # # TODO:本地测试使用代理
        # proxy = {'host': '47.241.21.129', 'pass': '', 'port': '59394', 'user': '', 'type': 'http'}
        # proxyInfo = {'proxyHost': proxy['host'],
        #              'proxyPort': int(proxy['port']),
        #              'proxyUser': proxy['user'],
        #              'proxyPass': proxy['pass'],
        #              'type': 1 if 'socks5' in proxy['type'] else 0}
        # # type 0 http | 1 sock5
        # print("手机登录代理IP", proxyInfo)
        # adId = user.adId if user.adId else str(uuid.uuid1())
        # deviceId = user.deviceId if user.deviceId else str(uuid.uuid1())
        # familyDeviceId = user.deviceId if user.deviceId else str(uuid.uuid1())
        # machineId = None if user.machineId is None else user.machineId
        # data_json = {
        #     "data": {"timeInMillis": int(time.time() * 1000), "type": "login", "taskId": str(uuid.uuid1()),
        #              "username": username,
        #              "data": {"adId": adId,
        #                       "device": json.dumps(device),
        #                       "deviceId": deviceId,
        #                       "familyDeviceId": familyDeviceId,
        #                       "machineId": machineId,
        #                       "makeProxy": makeProxy, "password": user.password,
        #                       "proxyInfo": proxyInfo,
        #                       "userId": 0, "username": username}}, "type": "task"}
        # for _ in range(3):
        #     rsp = requests.post(url="http://8.210.91.228:83/fb/api/login", json=data_json)
        #     back_json = rsp.json()
        #     print(f"手机登录{_}", back_json)
        #     code = back_json['code']
        #     if code == 200:
        #         phone_token = back_json['data']['accessToken']
        #         ddt = '{' + f"density=2.625,width={device['width']},height={device['height']}" + '}'
        #         phone_user_agent = f'[FBAN/FB4A;FBAV/294.0.0.35.118;FBBV/252996732;FBDM/{ddt};FBLC/en_US;FBRV/0;FBCR/;FBMF/{device["manufacturer"]};FBBD/{device["brand"]};FBPN/com.facebook.katana;FBDV/{device["model"]};FBSV/{device["release"]};FBOP/1;FBCA/{device["cpuAbi"]}:{device["cpuAbi2"]};]'
        #         phone_cookie = back_json['data']['cookies']
        #         machineId = back_json['data']['machineId']
        #         return phone_token, phone_user_agent, phone_cookie, adId, deviceId, familyDeviceId, machineId
        # else:
        #     return None, None, None, None, None, None, None

    def getToken(self, max_tries=3):
        block = re.compile('MCheckpointRedirect')
        m = re.compile(r'"accessToken":"(.*?)"')
        try:
            data = {
                'm_sess': None,
                'fb_dtsg': self._fb_dtsg,
                'jazoest': self.jazoest
            }

            res = self._post('https://m.facebook.com/composer/ocelot/async_loader/?publisher=feed', data)
            try:
                if block.search(res['payload']['actions'][1]['code']):
                    raise FBchatUserError('账号被封锁')
            except KeyError:
                pass
            access_token = m.search(res['payload']['actions'][2]['code']).group(1)
            return access_token
        except FBchatUserError:
            raise
        except:
            raise graph.GraphAPIError('无法获取Token')

    def _do_send_request(self, data):
        offline_threading_id = _util.generateOfflineThreadingID()
        data["client"] = "mercury"
        if 'action_type' not in data:
            data["action_type"] = "ma-type:user-generated-message"
        # data["author"] = "fbid:{}".format(self.user_id)
        data["timestamp"] = _util.now()
        data["source"] = "source:titan:web"
        # specific_to_list = list()
        # if 'other_user_fbid' in data:
        #     specific_to_list.append(data['other_user_fbid'])
        # if 'thread_fbid' in data:
        #     specific_to_list.append(data['thread_fbid'])
        # specific_to_list.append(self.user_id)
        # data['specific_to_list'] = specific_to_list
        # data['to_list_md5'] = hashlib.md5(':'.join(data['specific_to_list']).encode()).hexdigest()
        data["offline_threading_id"] = int(offline_threading_id)
        data["message_id"] = int(offline_threading_id)
        data["threading_id"] = _util.generateMessageID(self._client_id)
        data["ephemeral_ttl_mode"] = "0"
        # data["has_attachment"] = False
        j = self._post("/messaging/send/", data)

        # update JS token if received in response
        fb_dtsg = parse_html.get_fb_dtsg(j)
        if fb_dtsg is not None:
            self._fb_dtsg = fb_dtsg

        try:
            message_ids = [
                (action["message_id"], action["thread_fbid"])
                for action in j["payload"]["actions"]
                if "message_id" in action
            ]
            if len(message_ids) != 1:
                print("Got multiple message ids' back: {}".format(message_ids))
            return message_ids[0]
        except (KeyError, IndexError, TypeError) as e:
            raise _exception.FBchatException(
                "Error when sending message: "
                "No message IDs could be found: {}".format(j)
            )