#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020-02-05 16:58
# @Author  : Lemon
# @File    : facebook.py
# @Software: PyCharm
import base64
import json
import os
import random
import re
import time
from enum import Enum

import demjson
import furl
import requests
from fbchat import Client, ThreadType, Message, Sticker, FBchatUserError, _exception, log, _util
from fbchat._state import State, session_factory, is_home

from lib import google_map, common
from lib._mqtt import Mqtt
from lib.common import WorkPlace, College
from utils import parse_html, _attachment


class PCState(State):

    @classmethod
    def login(cls, email, password, on_2fa_callback, user_agent=None, proxy=None):
        '''换成了PC的登录方式'''
        session = session_factory(user_agent=user_agent)

        if proxy:
            short_proxy = common.format_proxies(proxy, 'requests')
            long_proxy = common.format_proxies(proxy, 'sock')
            session.params.update({'sock': long_proxy})
            session.proxies.update(short_proxy)

        soup = parse_html.find_input_fields_with_pc(session.get("https://www.facebook.com/").text)
        data = dict((elem["name"], elem["value"])
                    for elem in soup
                    if elem.has_attr("value") and elem.has_attr("name"))
        data['timezone'] = '-480'
        data['lgndim'] = 'eyJ3IjoxNDQwLCJoIjo5MDAsImF3IjoxNDQwLCJhaCI6Nzk4LCJjIjoyNH0='
        data['lgnjs'] = str(int(time.time()))
        data['locale'] = 'en_US'
        data['prefill_contact_point'] = email
        data['prefill_source'] = 'browser_dropdown'
        data['prefill_type'] = 'contact_point'
        data["email"] = email
        data["pass"] = password

        canvas = {"hash": "dc2744c681f26adf64542f5b693a7a92", "hash2": "7083187f11736b84501a1452607f72a8", "rounds": 5,
                  "seed": "0fd7b4f217e25c4ae853bd348ff40d73", "seed2": "6a8dcc015ce405274f47bc7cfa95f8ad",
                  "time_taken": int(random.random() * 1000000), "surface": "login"}
        data['skstamp'] = str(base64.b64encode(json.dumps(canvas).encode()), 'utf-8')

        r = session.post("https://www.facebook.com/login/device-based/regular/login/?login_attempt=1&lwv=110",
                         data=data)

        if 'device-based' in r.url:
            r = session.get("https://www.facebook.com/login.php?login_attempt=1", allow_redirects=False)
            r.url = r.headers["Location"] if "Location" in r.headers else r.url

        if is_home(r.url):
            return cls.from_session(session=session)
        else:
            raise _exception.FBchatUserError(
                "Login failed. Check email/password. "
                "(Failed on url: {})".format(r.url)
            )

    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)
        return "Location" in r.headers and is_home(r.headers["Location"])

    @classmethod
    def from_cookies(cls, cookies, user_agent=None, proxy=None):
        session = 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')

            session.params.update({'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)

        r = session.get(_util.prefix_url("/"), timeout=30)

        b = parse_html.show_home_page(r.text)
        logout_menu = b.find('div', id='logoutMenu')
        is_online = logout_menu is not None
        if is_online:
            id, name, url, image = parse_html.get_user_info(b)
        else:
            id = name = url = image = None

        fb_dtsg = None
        fb_dtsg_ag = None
        jazoest = None
        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:
            jazoest = re.search(r'name="jazoest" value="(\d+)"', r.text).group(1)
        except:
            pass

        revision = int(r.text.split('"client_revision":', 1)[1].split(",", 1)[0])

        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
        return self


class PostParam(Enum):
    EVERYONE = 300645083384735
    NETWORKS_FRIENDS = 123780391104836
    FRIENDS_OF_FRIENDS = 275425949243301
    FRIENDS = 291667064279714
    FRIENDS_MINUS_ACQUAINTANCES = 284920934947802
    ONLY_ME = 286958161406148
    FB_ONLY = 411331705596297
    EVENT_PUBLIC = 1493271774218406
    EVENT_INVITE_ONLY = 599950423437029


class RequestSource():
    const = {
        1: 'requests_page_pymk',
        2: 'profile_button',
        3: 'profile_friends',
        4: 'group_member_list',
        5: 'hovercard',
        6: 'browse',
    }

    @classmethod
    def get(cls, channel):
        if isinstance(channel, str):
            try:
                channel = int(channel)
            except:
                pass
        return cls.const.get(channel, channel)


class FacebookClient(Client):
    def __init__(self,
                 user_obj,
                 max_tries=1):

        self.email = user_obj.email
        self.user_obj = user_obj
        self.extend = None
        self.proxy = user_obj.proxy if hasattr(user_obj, 'proxy') else None

        super().__init__(user_obj.email, user_obj.password, user_obj.user_agent, max_tries, user_obj.format_cookie())

    def __repr__(self):
        return "client：%s" % self.email

    def setSession(self, session_cookies, user_agent=None):
        try:
            self._state = PCState.from_cookies(session_cookies, user_agent=user_agent, proxy=self.proxy)
            self._uid = self._state.user_id
        except Exception as e:
            log.exception("Failed loading session")
            return False
        return True

    def login(self, email, password, max_tries=5, user_agent=None):

        self.onLoggingIn(email=email)

        if max_tries < 1:
            raise FBchatUserError("Cannot login: max_tries should be at least one")

        if not (email and password):
            raise FBchatUserError("Email and password not set")

        for i in range(1, max_tries + 1):
            try:
                self._state = PCState.login(
                    email,
                    password,
                    on_2fa_callback=self.on2FACode,
                    user_agent=user_agent,
                    proxy=self.proxy
                )
                self._uid = self._state.user_id
            except Exception as err:
                if i >= max_tries:
                    raise err
                log.exception("Attempt #{} failed, retrying".format(i))
                time.sleep(1)
            else:
                self.onLoggedIn(email=email)
                break

    def get_cookie(self):
        cookies = self._state.get_cookies()
        ck = ["=".join(item) for item in cookies.items()]
        return '; '.join(ck)

    def _payload_get(self, url, data):
        j = self._state._get(url, data)
        try:
            return j["payload"]
        except (KeyError, TypeError):
            raise _exception.FBchatException("Missing payload: {}".format(j))

    def bannerInfo(self, fbid):
        res = self._payload_post('/ajax/messenger/context_banner/?profile_id=%s' % fbid, {'__user': self.uid})
        return res

    def addFriend(self, fbid, channel=1):
        how_found = RequestSource.get(channel)

        data = {
            "to_friend": fbid,
            "action": "add_friend",
            "how_found": how_found,
        }

        if how_found == 'profile_friends':
            data['ref_param'] = 'friends_tab'

        if how_found == 'profile_button':
            res = self._payload_post("/ajax/add_friend/action.php", data)
        else:
            res = self._payload_post("/ajax/add_friend/action?" + self._to_url_params(data), {})
        return res

    def previewName(self, primary_first, primary_middle, primary_last):
        data = {
            "primary_last_name": primary_last,
            "primary_middle_name": primary_middle or '',
            "primary_first_name": primary_first,
        }

        res = self._post(
            "/settings/name_change_preview/", data)
        return res

    def saveName(self, save_password, primary_first, primary_last, primary_middle=None, display_format='complete'):
        data = {
            'display_format': display_format,
            'save_password': save_password,
            'primary_first_name': primary_first,
            'primary_middle_name': primary_middle or '',
            'primary_last_name': primary_last
        }
        # 'alternate_name': 'lin wei quan', 'show_alternate': '1'
        res = self._post(
            "/ajax/settings/account/name.php", data)

        status = res['jsmods']['require'][0][1]
        if status == 'addError':
            html = res['jsmods']['require'][0][3][0]['__html']
            return {'success': False, 'error': parse_html.get_div_text(html)}
        elif status == 'setPreviewForCurrent':
            html = res['jsmods']['require'][0][3][0]['__html']
            return {'success': True, 'msg': parse_html.get_div_text(html)}
        raise BaseException('未知错误：' + json.dumps(res['jsmods']['require']))

    def uploudAvatar(self, binary):
        files = {
            'photo': binary
        }
        res = self._payload_post('/profile/picture/upload/?profile_id=%s&photo_source=9' % self.uid, {}, files=files)
        try:
            return res['fbid']
        except:
            return None

    def setAvatar(self, photo_id):
        '''
        设置头像
        '''
        data = {'x': '0', 'y': '0', 'width': '1', 'height': '1',
                'photo_id': photo_id, 'profile_id': self.uid,
                'source': 'timeline'}  # 'source': 'unknown', 'method': 'upload'

        res = self._payload_post('/profile/picture/crop_profile_pic/?' + self._to_url_params(data), {})
        return res

    def setBio(self, content):
        '''
        设置简介
        '''
        data = {'bio': content, 'bio_expiration_time': '-1', 'intro_card_session_id': ''}
        res = self._post('/profile/intro/bio/save/', data)
        html = parse_html.get_domops_3(res)
        if 'profile_intro_card_bio' in html:
            return {"success": True}
        return res

    def addWorkPlace(self, workplace: WorkPlace, value='EVERYONE'):
        '''添加工作经历'''
        value = PostParam.__dict__.get(value).value
        data = {
            # 'hub_id': '142351455848493',
            'type': '2002',
            'ref': 'about_tab',
            'action_type': 'add',  # add | edit
            'experience_id': '0',
            'privacy[741155019280009]': value
        }
        data.update(workplace.to_dict())
        res = self._post('/profile/edit/work/save/', data)
        try:
            return {
                'success': True,
                'setting': res['jsmods']['require'][1][3][0]['props']
            }
        except:
            return {
                'success': False,
                'error': res['jsmods']['require']
            }

    def addCollege(self, college: College, value='EVERYONE'):
        '''添加教育记录'''

        value = PostParam.__dict__.get(value).value
        data = {
            'experience_type': '2004',
            'degree_id': '0',
            'degree_text': '',
            'ref': 'about_tab',
            'action_type': 'add',
            'experience_id': '0',
            'privacy[1588594478034907]': value}
        data.update(college.to_dict())
        res = self._post('/profile/edit/edu/save/', data)
        try:
            return {
                'success': True,
                'setting': res['jsmods']['require'][1][3][0]['props']
            }
        except:
            return {
                'success': False,
                'error': res['jsmods']['require']
            }

    def setCurrentCity(self, city_id, city_name):
        '''
        设置当前城市
        '''
        data = {'current_city_text': city_name, 'current_city': city_id,
                'privacy[8787650733]': PostParam.EVERYONE.value}
        res = self._post('/profile/async/edit/infotab/save/current_city/', data)
        if city_id in res['domops'][0][3]['__html']:
            return {"success": True}
        return {"success": False}

    def setHometown(self, city_id, city_name):
        '''
        设置家乡地址
        '''
        data = {'hometown_text': city_name, 'hometown': city_id,
                'nctr[_mod]': 'pagelet_hometown',
                'privacy[8787655733]': PostParam.EVERYONE.value}
        res = self._post("/profile/async/edit/infotab/save/hometown/", data)
        if city_id in res['domops'][0][3]['__html']:
            return {"success": True}
        return {"success": False}

    def setGender(self, gender: str):
        '''
        设置性别 boy or girl
        '''
        sex = 2 if gender.lower() == 'boy' else 1
        data = {'sex': sex, 'sex_preferred_pronouns': '1',
                'privacy[237760973066217]': PostParam.ONLY_ME.value}
        res = self._post('/profile/edit/infotab/save/gender/', data)

        html = parse_html.get_domops_3(res)
        if 'gender' in html:
            return {"success": True}
        else:
            raise BaseException("未知错误：", html)

    def setSexualOrientation(self, sex: int):
        '''
        设置性取向 1女性 2男性  3双性
        '''

        data = {
            'privacy[8787590733]': PostParam.EVERYONE.value
        }
        if sex == 1 or sex == 3:
            data['meeting_sex1'] = 'on'
        if sex == 2 or sex == 3:
            data['meeting_sex2'] = 'on'
        res = self._post('/profile/edit/infotab/save/interested_in/', data)
        html = parse_html.get_domops_3(res)
        if 'interested_in' in html:
            return {"success": True}
        else:
            raise BaseException("未知错误：", html)

    def sendSticker(self, sticker_id, thread_id, thread_type=ThreadType.USER):
        return self.send(
            Message(sticker=Sticker(uid=sticker_id),
                    emoji_size=None, reply_to_id=None, text=None),
            thread_id=thread_id,
            thread_type=thread_type
        )

    def _parse_link(self, link):
        data = {"image_height": 144, "image_width": 144, 'uri': link}
        return self._payload_post('/message_share_attachment/fromURI/', data)

    def sendPictureLink(self, link, thread_id, thread_type=ThreadType.USER):
        thread_id, thread_type = self._getThread(thread_id, thread_type)
        thread = thread_type._to_class()(thread_id)
        data = thread._to_send_data()
        data.update({
            'action_type': 'ma-type:user-generated-message',
            'body': '', 'ephemeral_ttl_mode': '0', 'has_attachment': '1',
            'timestamp': int(time.time() * 1000)
        })
        if thread_type == ThreadType.USER:
            data["specific_to_list[0]"] = "fbid:{}".format(thread_id)
            data["specific_to_list[1]"] = "fbid:{}".format(self.uid)
        info = _attachment.parse(self._parse_link(link))
        data.update(info)
        return self._doSendRequest(data)

    def friendRequest(self):
        '''收到的好友请求'''
        url = None
        empty = False
        ids, names = [], []

        while True:
            if not (ids or names):
                if empty:
                    return
                ids, names, url = self._friendRequest(url)
                if not url:
                    empty = True
            sub = (ids.pop(0), names.pop(0))
            yield sub

    def _friendRequest(self, url=None, require_gender=True):
        if url:
            j = self._post(url, params={})
        else:
            data = {'log_impressions': 'true', 'reloadcontent': 'false'}
            j = self._post('/ajax/requests/loader/', data)
        result, next_url = parse_html.friend_unit(j)

        if require_gender and result:
            ids = [x['fbid'] for x in result]
            users = self.fetchUserInfo(*ids)
            for r in result:
                gender = users.get(r['fbid']).gender
                r['gender'] = 'boy' if 'male_singular' == gender else \
                    ('girl' if 'female_singular' == gender else 'unknown')

        return result, next_url

    def deleteRequest(self, fbid):
        data = {'confirm': fbid,
                'type': 'friend_connect',
                'request_id': fbid,
                'list_item_id': '%s_1_req' % fbid,
                'status_div_id': '%s_1_req_status' % fbid,
                'inline': '1',
                'ref': 'jewel',
                'ego_log': '',
                'actions[reject]': '1',
                # 'nctr[_mod]': 'pagelet_bluebar'
                }
        res = self._post('/ajax/reqs.php', data)
        detail = res['domops'][0]
        if detail[0] == 'setContent' and detail[2]:
            return {"success": True}
        raise BaseException("未知错误:" + json.dumps(detail))

    def pymkRequest(self) -> tuple:
        '''
        可能认识的人
        :return (ID,Name)
        '''
        total_ids = []
        res = []

        while True:
            if not res:
                res = self._pymk_request(total_ids)
                ids = [x['fbid'] for x in res]
                total_ids.extend(ids)
                if not ids:
                    return
            sub = res.pop(0)
            yield sub

    def _pymk_request(self, total_ids: list):
        data = {
            'how_found': 'requests_page_pymk',
            'page': 'friends_center',
            'instance_name': 'friend-browser',
            'big_pics': 1,
            'social_context': 1,
            'network_context': 1,
            'show_more': True
        }

        for index, id in enumerate(total_ids):
            data['friend_browser_id[%d]' % index] = id

        j = self._post("/ajax/growth/friend_browser/checkbox.php", data)
        result, _ = parse_html.friend_unit(j)

        if result:
            ids = [x['fbid'] for x in result]
            users = self.fetchUserInfo(*ids)
            for r in result:
                id = r['fbid']
                gender = users.get(id).gender
                r['gender'] = 'boy' if 'male_singular' == gender else \
                    ('girl' if 'female_singular' == gender else 'unknown')

        return result

    def pymkRemove(self, fbid):
        '''
        移除可能认识的人
        :return
        '''
        data = {'uid': fbid,
                'src_page': 'pymk_jewel',
                'how_found': 'people_you_may_know',
                'nctr[_mod]': 'pagelet_bluebar'}
        res = self._post('/friends/pymk/xout/', data)
        if res['payload'] == None:
            return {"success": True}
        raise BaseException("未知错误:" + json.dumps(res))

    def _to_url_params(self, data: dict):
        return '&'.join(["{}={}".format(k, v) for k, v in data.items()])

    def followPage(self, page_id, status=True):
        '''关注热门主页'''
        data = {'page_id': page_id, 'status': status, 'location': '141', 'qoc_dialog_button': 'false'}
        res = self._post('/page/follow_mutator/?' + self._to_url_params(data), {})
        return res

    def likePage(self, page_id, status=True):
        '''点赞热门主页'''
        data = {'fbpage_id': page_id,
                'add': status, 'reload': 'false',
                'fan_origin': 'page_profile',
                'actor_id': self._uid,
                }
        res = self._post('/ajax/pages/fan_status.php?av=' + self._uid, data)
        return res

    def outgoingRequest(self):
        '''发出的加好友请求'''
        url = None
        empty = False
        res = []

        while True:
            if not res:
                if empty:
                    return
                res, url = self._outgoingRequest(url)
                if not url:
                    empty = True
                if not res:
                    empty = True
            else:
                sub = res.pop(0)
                yield sub

    def _outgoingRequest(self, url=None, require_gender=True):
        if url:
            j = self._get(url, {})
        else:
            data = {'page': 1, 'page_size': '10',
                    'pager_id': 'outgoing_reqs_pager_5e3a685eb1075' + os.urandom(5).hex()}
            j = self._get("/friends/requests/outgoing/more/", data)

        result, next_url = parse_html.friend_unit(j)

        if require_gender and result:
            ids = [x['fbid'] for x in result]
            users = self.fetchUserInfo(*ids)
            for r in result:
                gender = users.get(r['fbid']).gender
                r['gender'] = 'boy' if 'male_singular' == gender else \
                    ('girl' if 'female_singular' == gender else 'unknown')
        return result, next_url

    def cancelRequest(self, fbid):
        '''
        取消好友申请
        :return
        '''
        data = {
            'friend': fbid,
            'cancel_ref': 'outgoing_requests',
        }
        res = self._post('/ajax/friends/requests/cancel.php', data)
        detail = res['jsmods']['require'][0]
        if 'FriendRequest/cancel' in json.dumps(detail[3]):
            return {'success': True}
        raise BaseException("未知错误:" + json.dumps(detail))

    def searchForCity(self, city):
        query = {
            "query_params": {"query": city, "viewer_coordinates": {}, "provider": "here_thrift",
                             "search_type": "city_typeahead", "integration_strategy": "string_match",
                             "result_ordering": "interleave", "caller": "profile_about",
                             "page_category": ["city", "subcity"], "geocode_fallback": False}, "max_results": 10,
            "photo_width": 50, "photo_height": 50
        }
        data = {
            "query_id": 1529221910536355,
            "variables": json.dumps(query)
        }
        f = furl.furl("https://www.facebook.com/webgraphql/query/").add(data)
        res = self._payload_post(f.url.replace("+", ""), {})
        return res

    def searchForCompany(self, name):
        '''搜索公司'''
        data = {'value': name, 'existing_ids': '', 'category': '2200', 'context': 'hub_work', 'filter[0]': 'page',
                'section': '2002', 'services_mask': '1', 'viewer': self.uid}
        url = furl.furl("https://www.facebook.com/ajax/typeahead/search.php").add(data).url
        res = self._payload_get(url, {})
        return res

    def searchForCollege(self, name):
        '''搜索学校'''
        data = {'value': name, 'existing_ids': '', 'category': '2602', 'context': 'hub_college', 'filter[0]': 'page',
                'section': '2004', 'services_mask': '1', 'viewer': self.uid}
        url = furl.furl("https://www.facebook.com/ajax/typeahead/search.php").add(data).url
        res = self._payload_get(url, {})
        return res

    def searchForPosition(self, name):
        '''搜索职位'''
        data = {'value': name, 'existing_ids': '', 'category': '2611', 'context': 'hub_work_position',
                'filter[0]': 'page', 'section': '2002', 'services_mask': '1',
                'viewer': self.uid}
        url = furl.furl("https://www.facebook.com/ajax/typeahead/search.php").add(data).url
        res = self._payload_get(url, {})
        return res

    def searchForConcentration(self, name):
        '''搜索专业学科'''
        data = {'value': name, 'existing_ids': '', 'category': '2609', 'context': 'hub_school_concentration',
                'filter[0]': 'page', 'page_categories[0]': '2609', 'page_categories[1]': '2608', 'section': '2004',
                'services_mask': '1', 'viewer': self.uid}
        url = furl.furl("https://www.facebook.com/ajax/typeahead/search.php").add(data).url
        res = self._payload_get(url, {})
        return res

    def getOverview(self):
        data = {
            "dom_section_id": "u_0_2e",
            "profile_id": self.uid,
            "section": "overview",
            "viewer_id": self.uid,
            "lst": "%s:%s:%d" % (self.uid, self.uid, int(time.time()))
        }
        f = furl.furl("https://www.facebook.com/profile/async/infopage/nav/").add(data)
        res = self._post(f.url, {})
        return parse_html.get_overview_text(res)

    def getUserLive(self, fbid):
        data = {
            "dom_section_id": "u_0_%d" % random.randint(10, 40),
            "profile_id": fbid,
            "section": "places",
            "viewer_id": self.uid,
            "lst": "%s:%s:%d" % (self.uid, fbid, int(time.time()))
        }
        f = furl.furl("https://www.facebook.com/profile/async/infopage/nav/").add(data)
        res = self._post(f.url, {})
        city_text, city_id = parse_html.get_current_city(res)
        assert city_id, "未设置当前地区"
        location = self._getLatlng(city_id)
        assert location, '未获取到经纬度'
        country = google_map.get_country(location)
        return city_id, city_text, country

    def _getLatlng(self, city_id):
        data = {'av': self.uid, 'fb_api_caller_class': 'RelayModern',
                'fb_api_req_friendly_name': 'CityPageHeaderRootQuery',
                'variables': json.dumps({"page": city_id}),
                'doc_id': '2749700208407754'}
        res = self._post('/api/graphql/', data)
        try:
            return res['data']['page']['location']
        except:
            return None

    def uploadCover(self, binary):
        '''上传首页封面'''
        files = {
            'pic': binary
        }
        data = {'target_id': self.uid, 'profile_id': self.uid, 'source': '10'}
        res = self._post('https://upload.facebook.com/ajax/timeline/cover/upload/', data, files=files)
        result = res['jsmods']['require'][0]
        status = result[1]
        detail = result[3]
        if isinstance(detail[0], int):
            return str(detail[0])
        raise BaseException(status + ' ' + ':'.join(detail[3]))

    def setCover(self, photo_id):
        '''设置封面图片'''
        data = {
            'photo_id': photo_id, 'profile_id': self.uid, 'photo_offset_y': '',
            'photo_offset_x': '', 'save': '1',
            'nctr[_mod]': 'pagelet_timeline_main_column'
        }
        res = self._post("/ajax/timeline/cover_photo_select.php?av=%s" % self.uid, data)
        html = parse_html.get_domops_3(res)
        m = re.search(r'src="(.*?)"', html)
        if m:
            return {'src': m.group(1).replace('&amp;', '&')}
        raise BaseException("设置封面未知错误：" + json.dumps(res['jsmods']['require'][0]))

    def info(self):
        data = {
            'fbid': self._state.id,
            'name': self._state.name,
            'page_url': self._state.page_url,
            'imageurl': self._state.imageurl
        }
        return data

    def followProfile(self, fbid, status=True):
        '''关注个人主页'''
        data = {
            'profile_id': fbid,
            'location': 1,
        }
        if status:
            url_ = '/ajax/follow/follow_profile.php'
        else:
            url_ = '/ajax/follow/unfollow_profile.php'
        res = self._post(url_, data)
        if 'onload' not in res:
            raise BaseException("未知错误:" + res)

        onloads = json.dumps(res['onload'])
        if 'Arbiter.inform' in onloads:
            return {"success": True}
        raise BaseException("未知错误:" + onloads)

    def get_user_agent(self):
        return self._state._session.headers.get('User-Agent', random.choice(_util.USER_AGENTS))

    def searchForUserByFilter(self, name, city_id, ext_data=None):
        if not ext_data:
            from urllib import parse
            tob64 = lambda x: str(base64.b64encode(x.encode('utf-8')), 'utf-8')
            filter = json.dumps({'city': json.dumps({"name": "users_location", "args": str(city_id)})})
            b64 = tob64(filter)

            r = self._state._session.get(
                f'https://www.facebook.com/search/people/?q={parse.quote(name)}&epa=FILTERS&filters={b64}')
            fbid = parse_html.get_all_raw_id(r.text)

            global_data = re.findall(r'globalData:(\{.*?display_params.*?\}),prefetchPixels', r.text)[0]
            data = demjson.decode(global_data)
            complete = re.findall('"pageletComplete",\[\],\[(.*?)\]', r.text)[0]
            data.update(demjson.decode(complete))
            return {'fbid_list': fbid, 'ext_data': data}
        else:
            data = {'data': demjson.encode(ext_data), 'fb_dtsg_ag': self._state.fb_dtsg_ag}
            res = self._state._get('https://www.facebook.com/ajax/pagelet/generic.php/BrowseScrollingSetPagelet', data)
            ext_data.pop('page_number')
            try:
                for x in res.get('jsmods').get('require'):
                    if len(x) == 4 and x[1] == 'pageletComplete':
                        ext_data.update(x[3][0])
                        break
            except:
                pass

            fbid = parse_html.get_all_raw_id(res['payload'])
            return {
                'fbid_list': fbid,
                'ext_data': ext_data,
            }

    def friendsList(self, ext_data=None, fbid=None):
        if ext_data:
            ext_data = common.frombase64(ext_data)

            if 'collection_token' in ext_data:
                data = {
                    'fb_dtsg_ag': self._state.fb_dtsg_ag,
                    'data': demjson.encode(ext_data),
                }
                res = self._get('/ajax/pagelet/generic.php/AllFriendsAppCollectionPagelet', data)

                cursor = parse_html.get_pagelet_info(res)
                ext_data.update({'cursor': cursor})

                res = parse_html.get_friend_div(res.get('payload'))
                res['items']['ext_data'] = ext_data
                res['items']['count'] = ext_data['count']
                res['items']['has_next_page'] = not cursor is None
            else:
                data = {'av': self.uid,
                        'fb_api_caller_class': 'RelayModern',
                        'fb_api_req_friendly_name': 'ProfileCometAppCollectionListRendererPaginationQuery',
                        'variables': json.dumps({"count": 20,
                                                 "cursor": ext_data['cursor'],
                                                 "search": None, "scale": 2,
                                                 "privacySelectorRenderLocation": "COMET_PROFILE_COLLECTIONS",
                                                 "id": ext_data['id']}),
                        'doc_id': '2773917206008873'}
                res = self._post('/api/graphql/', data)
                res = res['data']['node']

        else:

            if fbid:
                # url = f'https://www.facebook.com/{fbid}/friends'
                url = f'https://www.facebook.com/profile.php?id={fbid}&sk=friends'
            else:
                url = self._state.page_url.replace('profile.php?id=', '') + '/friends'

            res = self._state._session.get(url)
            if res.status_code == 200 and 'friends' in res.url:
                res = parse_html.get_friend_div(res.text)
                if not res:
                    respone = {
                        'items': [],
                        'count': 0,
                        'ext_data': {},
                        'has_next_page': False
                    }
                    return respone
            else:
                raise BaseException("网络访问异常，utl=", res.url)
        edges = res['items']['edges']
        count = res['items']['count']
        friends = []
        for edge in edges:
            node = edge['node']
            data = {
                'image': node['image']['uri'],
                'name': node['title']['text'],
                'fbid': node['node']['id'],
                'url': node['node']['url']
            }
            friends.append(data)

        if 'page_info' in res['items']:
            respone = {
                'items': friends,
                'count': count,
                'ext_data': {
                    'id': res['id'],
                    'cursor': res['items']['page_info']['end_cursor']
                },
                'has_next_page': res['items']['page_info']['has_next_page']
            }
        elif 'ext_data' in res['items']:
            respone = {
                'items': friends,
                'count': count,
                'ext_data': res['items']['ext_data'],
                'has_next_page': res['items']['has_next_page'],
            }
        else:
            respone = {
                'items': [],
                'count': 0,
                'ext_data': {},
                'has_next_page': False
            }
        respone['ext_data'] = common.tobase64(respone['ext_data'])
        return respone

    def changePwd(self, old, new):
        data = {
            'recommended': False,
            'fb_dtsg_ag': self._state.fb_dtsg_ag,
        }
        res = self._state._get('/settings/security/password/', data, 0)
        data = parse_html.get_hidden_input(res)
        assert 'password_change_session_identifier' in data, '参数不足：session_identifier未获取到'
        data.update({
            "password_strength": 2,
            'password_old': old,
            'password_new': new,
            'password_confirm': new,
        })
        res = self._post('/ajax/settings/security/password.php', data)
        title = res['jsmods']['require'][0][0]
        if title == 'SecuritySettingsPasswordErrorHandler':
            html = res['jsmods']['require'][0][3][0]['__html']
            error = parse_html.get_div_text(html)
            return {'success': False, 'error': error}
        elif title == 'JSPasswordChangeReason':
            return {'success': True, 'error': None}
        else:
            raise BaseException('未知错误:' + json.dumps(res['jsmods']['require']))

    def setFriendListPrivate(self, value):
        value = PostParam.__dict__.get(value).value
        data = {'privacy_fbid': '8787365733', 'post_param': value, 'render_location_enum': 'settings',
                'is_saved_on_select': 'true', 'should_return_tooltip': 'false',
                'prefix_tooltip_with_app_privacy': 'false', 'ent_id': '0', 'user_id': self._uid}
        self._post('https://www.facebook.com/privacy/selector/update?' + self._to_url_params(data), {})
        data = {
            'post_param': value,
            'value': value,
            'saved_custom_opt_in': True,
        }
        res = self._post('/ajax/settings/granular_privacy/friendlist.php', data)
        if 'fbSettingsListItem' in res['domops'][0][1]:
            return {"success": True}
        return {"success": False}

    def setCanFriendReq(self, value):
        value = PostParam.__dict__.get(value).value
        data = {'privacy_fbid': '8787540733', 'post_param': value, 'render_location_enum': 'settings',
                'is_saved_on_select': True, 'should_return_tooltip': 'false',
                'prefix_tooltip_with_app_privacy': False, 'ent_id': '0', 'user_id': self.uid}
        self._post('/privacy/selector/update/?' + self._to_url_params(data), {})
        data = {'post_param': value, 'saved_custom_opt_in': 'true', 'value': value}
        res = self._post('/ajax/settings/granular_privacy/can_friend_req.php', data)
        if 'fbSettingsListItem' in res['domops'][0][1]:
            return {"success": True}
        return {"success": False}

    def setBirthday(self, year, month, day):
        data = {
            'privacy[8787510733]': PostParam.EVERYONE.value,
            'privacy[8787805733]': PostParam.EVERYONE.value,
            'birthday_month': month, 'birthday_day': day, 'birthday_year': year,
            'birthday_confirmation': '1',
            'bd_surface': 'www_profile', 'edit_birthday_allowed': '0',
            '__submit__': '1', 'nctr[_mod]': 'pagelet_basic'
        }
        res = self._post('/profile/edit/infotab/save/birthday/', data)
        html = parse_html.get_domops_3(res)
        if 'birthday' in html:
            return {"success": True}
        else:
            raise BaseException("未知错误：", html)

    def setLanguage(self, language):
        data = {
            'new_language': language,
            'new_fallback_language': '',
        }
        res = self._post('/ajax/settings/language/account.php', data)
        return {"success": True}

    def inboxMessenger(self, ext_data=0):
        if ext_data:
            info = self.fetchThreadList(before=int(ext_data))
        else:
            info = self.fetchThreadList()
        next_data = info[-1].last_message_timestamp if info else 0
        friends = []
        for foo in info:
            if ThreadType.GROUP == foo.type:
                friends.append({
                    'type': foo.type.name,
                    'fbid': foo.uid,
                    'name': foo.name,
                    'image': foo.photo,
                    'url': None,
                    'gender': None,
                    'message_count': foo.message_count,
                    'members': list(foo.participants),
                })
            elif ThreadType.USER == foo.type:
                friends.append({
                    'type': foo.type.name,
                    'fbid': foo.uid,
                    'name': foo.name,
                    'image': foo.photo,
                    'url': foo.url,
                    'gender': 'boy' if foo.gender == 'male_singular' else 'girl',
                    'message_count': foo.message_count,
                })

        response = {
            'items': friends,
            'ext_data': next_data
        }
        return response

    def startListening(self):
        if not self._mqtt:
            self._mqtt = Mqtt.connect(
                state=self._state,
                on_message=self._parse_message,
                chat_on=self._markAlive,
                foreground=True,
            )
            self.onQprimer(ts=int(time.time() * 1000), msg=None)
        self.listening = True

    def securityDevice(self):
        data = {'av': self.uid, 'fb_api_caller_class': 'RelayModern',
                'fb_api_req_friendly_name': 'SecuritySettingsSessionGroupRefetchQuery',
                'variables': '{"session_count":20}', 'doc_id': '2549907381730805'}
        res = self._post('https://www.facebook.com/api/graphql/', data)
        return res['data']['security_settings']['sessions']