#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/3/30 3:57 下午
# @Author  : Lemon
# @File    : state.py
# @Software: PyCharm
import json
import linecache
import random
import re
import time

import requests
from fbchat import FBchatUserError, _exception, _util
from fbchat._state import State, is_home
from requests import Session as Session_

from lib import common, graph
from utils import parse_html, encpass


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)
            content = res.text
            set_cookie = res.headers.get('Set-Cookie', None)
            if 'checkpoint' in res.url:
                # self.get_deal_lock_method(int(kwargs['data']['jazoest']), kwargs['data']['lsd'])
                raise FBchatUserError('账号被封锁:' + parse_html.checkpoint_text(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_init_lock_args(self, jazoest: str, lsd: str):
        """
        获取解封方式 所需要参数
        """
        res = super().request('GET', 'https://www.facebook.com/checkpoint/?next')
        args = parse_html.get_lock_init(res.text)
        fb_dtsg_ag = args[0]
        nh = args[1]
        params = {
            'modules': 'FormSubmit',
            "dpr": 2,
            "fb_dtsg_ag": fb_dtsg_ag,
            "jazoest": jazoest,
            "nh": nh,
            "lsd": lsd
        }
        return params

    def get_deal_lock_method(self, jazoest, lsd):
        params = self.get_init_lock_args(jazoest, lsd)
        res = super().request('GET', 'https://www.facebook.com/ajax/bootloader-endpoint',
                              params=params)

        res = super().request('POST', 'https://www.facebook.com/cookie/consent/',
                              params=params)

        params['submit[Continue]'] = 'Continue'
        res = super().request('POST',
                              'https://www.facebook.com/checkpoint/async?next'
                              , data=params
                              )
        pass


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,en;q=0.5
        cache-control: no-cache
        pragma: no-cache
        sec-fetch-dest: document
        sec-fetch-mode: navigate
        sec-fetch-site: none
        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: 1920'''
        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)
        return session

    @classmethod
    def login2(cls, user_obj, proxy=None):
        session = cls.session_factory(user_agent=user_obj.user_agent)

        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})
            session.proxies.update(short_proxy)
        text = session.get("https://www.facebook.com/").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"))
        pubkey, keyid = parse_html.get_publickey_id(text)

        data.update({
            'ab_test_data': common.ABTESTDATA(user_obj.password).get(),
            'email': user_obj.email,
            # 'ep': encpass.pc_encrypt(user_obj.password, keyid, pubkey),
            'encpass': encpass.pc_encrypt(user_obj.password, keyid, pubkey),
            'guid': encpass.guid(),
            'lgndim': 'eyJ3IjoxNDQwLCJoIjo5MDAsImF3IjoxNDQwLCJhaCI6Nzk1LCJjIjoyNH0=',
            'next': 'https://www.facebook.com/',
            'prefill_contact_point': user_obj.email,
            'prefill_source': 'browser_dropdown',
            # 'prefill_type': 'password',
            'prefill_type': 'contact_point',
            'lgnjs': int(time.time()),
            'timezone': '-480'
        })
        r = session.post('https://www.facebook.com/login/device-based/regular/login/?login_attempt=1&lwv=110',
                         data=data)
        setCookie = r.headers.get('Set-Cookie') or ''

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

        if 'checkpoint' in setCookie or 'checkpoint/' in r.text:
            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 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)
            )

    @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

        # f_url=furl.furl(r.url)
        # if f_url.host=='m.facebook.com' and f_url.path=='/':
        if session.mobile:
            b = parse_html.show_home_page(r.text)
            messages_jewel = b.find('div', id='messages_jewel')
            language = re.search(r'LocaleInitialData",\[\],\{locale:"(.*?)",', r.text).group(1)
            is_online = messages_jewel 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('账号被封锁')
        else:
            try:
                b = parse_html.show_home_page(r.text)
                logout_menu = b.find('div', id='logoutMenu')
                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)
        if session.mobile:
            try:
                fb_dtsg = re.search(r'name="fb_dtsg" value="(.*?)"', r.text).group(1)
                fb_dtsg_ag = re.search(r'"dtsg_ag":{"token":"(.*?)"', r.text).group(1)
            except:
                pass
        else:
            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)
            revision = int(r.text.split('"client_revision":', 1)[1].split(",", 1)[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 getToken(self, max_tries=3):
        # block = re.compile('MCheckpointRedirect')
        # m = re.compile(r'"accessToken":"(.*?)"')
        # try:
        #     res = self._post('https://m.facebook.com/composer/ocelot/async_loader/?publisher=feed', {'m_sess': ''})
        #     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')
        if max_tries < 1:
            raise FBchatUserError("Cannot getToken: max_tries should be at least one")

        _token = None
        for i in range(1, max_tries + 1):
            try:
                url = 'https://m.facebook.com/composer/mbasic/?av=' + self.user_id
                data = "fb_dtsg=" + self._fb_dtsg + "&target=" + self.user_id + "&c_src=feed&referrer=feed&photo_upload"
                res = self._session.post(url, data, headers={'Content-Type': 'application/x-www-form-urlencoded'})
                if res.text.count('/help/'):
                    raise AssertionError('账号被限制，无法获取Token，登录失败')
                _token = re.search(r'"(EAAA.*?)"', res.text).group(1)
            except AssertionError:
                raise
            except Exception:
                if i >= max_tries:
                    raise graph.GraphAPIError('无法获取Token')
                print("Attempt #{} failed, retrying".format(i))
                time.sleep(1)
            else:
                break
        return _token

    def _do_send_request(self, data):
        offline_threading_id = _util.generateOfflineThreadingID()
        data["client"] = "mercury"
        data["author"] = "fbid:{}".format(self.user_id)
        data["timestamp"] = _util.now()
        data["source"] = "source:chat:web"
        data["offline_threading_id"] = offline_threading_id
        data["message_id"] = offline_threading_id
        data["threading_id"] = _util.generateMessageID(self._client_id)
        data["ephemeral_ttl_mode:"] = "0"
        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)
            )


class MobileState(State):

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

    @classmethod
    def session_factory(cls, user_agent=None):
        session = Session()
        session.headers["Referer"] = "https://m.facebook.com/"
        session.headers["User-Agent"] = user_agent or cls.random_useragent()
        return session

    @classmethod
    def login2(cls, user_obj, proxy=None):
        session = cls.session_factory(user_agent=user_obj.user_agent)
        if 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)
        text = session.get("https://m.facebook.com/").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"))

        token = re.findall(r'{"dtsg":{"token":"(.*?)"', text)
        if token:
            token = token[0]
        else:
            token = ''
        data.update({'fb_dtsg': token})
        print(data)