import logging
import time
from threading import Thread
import traceback
import uuid
import requests
from django.conf import settings
from rest_framework.exceptions import APIException, ParseError

from apps.third.errors import XX_REQUEST_ERROR
from apps.third.models import Tlog
from apps.utils.tools import print_roundtrip
from django.utils.timezone import now

requests.packages.urllib3.disable_warnings()
myLogger = logging.getLogger('log')


class XxClient:
    """
    寻息
    """

    def __init__(self, licence=settings.XX_LICENCE, username=settings.XX_USERNAME) -> None:
        if settings.XX_ENABLED:
            self.licence = licence
            self.username = username
            self.isGetingToken = False
            self.isRuning = True
            self.token = ''
            self.log = {}
            self.t = None
            self.setup()

    def _get_token_loop(self):
        while self.isRuning:
            json = {
                'licence': self.licence
            }
            try:
                r = requests.post(json=json, url=settings.XX_BASE_URL + '/getAccessTokenV2', verify=False, timeout=20)
                ret = r.json()
                if ret.get('errorCode', 1) == 0:
                    self.token = ret['data']['token']
                time.sleep(1200)
            except Exception:
                myLogger.error('寻息服务连接失败', exc_info=True)

    def get_token(self):
        self.isGetingToken = True
        json = {
            'licence': self.licence
        }
        r = requests.post(json=json, url=settings.XX_BASE_URL + '/getAccessTokenV2', verify=False, timeout=20)
        ret = r.json()
        if ret.get('errorCode', 1) == 0:
            self.isGetingToken = False
            self.token = ret['data']['token']

    def setup(self):
        self.t = Thread(target=self._get_token_loop, args=(), daemon=True)
        self.t.start()

    def __del__(self):
        """
        自定义销毁
        """
        self.isRuning = False
        # self.t.join()

    def request(self, url: str, method: str = 'post', params=dict(), json=dict(), timeout=4, raise_exception=True):
        if not settings.XX_ENABLED:
            raise ParseError('寻息对接未启用')
        params['accessToken'] = self.token
        json['username'] = self.username
        json['buildId'] = settings.XX_BUILDID
        self.log = {"requested_at": now(), "id": uuid.uuid4(), "path": url, "method": method,
                    "params": params, "body": json, "target": "xunxi", "result": 10}
        if self.isGetingToken:
            req_num = 0
            while True:
                time.sleep(0.5)
                if not self.isGetingToken:
                    self.request(url, method, params, json, timeout, raise_exception)
                req_num = req_num + 1
                if req_num > 4:
                    break
        else:
            r = getattr(requests, method)('{}{}'.format(settings.XX_BASE_URL, url),
                                          params=params, json=json, timeout=timeout, verify=False)
            # if settings.DEBUG:
            #     print_roundtrip(r)
            ret = r.json()
            if ret.get('errorCode') in ['1060000', 1060000]:
                self.get_token()  # 重新获取token
                self.request(url, method, params, json, timeout, raise_exception)  # 重新请求
            else:
                if ret['errorCode'] != 0:
                    err_detail = dict(detail='寻息错误:' + '|'.join(ret['errorMsg']),
                                      code='xx_' + str(ret['errorCode']))
                    self.handle_log(result='fail', response=ret)
                    if raise_exception:
                        raise ParseError(**err_detail)
                    return 'fail', err_detail
                # self.handle_log(result='success', response=None)
                return 'success', ret['data']
        self.handle_log(result='error', errors=traceback.format_exc())
        if raise_exception:
            raise APIException(**XX_REQUEST_ERROR)
        return 'error', XX_REQUEST_ERROR

    def _get_response_ms(self):
        """
        Get the duration of the request response cycle is milliseconds.
        In case of negative duration 0 is returned.
        """
        response_timedelta = now() - self.log["requested_at"]
        response_ms = int(response_timedelta.total_seconds() * 1000)
        return max(response_ms, 0)

    def handle_log(self, result, response=None, errors=None):
        self.log.update({
            "result": result,
            "response": response,
            "response_ms": self._get_response_ms(),
            "errors": errors
        })
        Tlog(**self.log).save()