# coding: utf-8

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

import json
import logging
import os
import socket

import time

import jwt

from byteddps.cache import Cache
from byteddps.errors import DpsError
from byteddps.identity import Identity, ZeroTrustIdentity

UNIX_DOMAIN_SOCKET_PATH = "/opt/tmp/sock/.unix_sock_agent_1234567890.sock"

logger = logging.getLogger("byteddps")


def is_token_jwt_svid(token_str):
    try:
        header = jwt.get_unverified_header(token_str)
    except Exception as ex:
        raise DpsError(ex)
    kid = "kid"
    return kid in header


class Client(object):
    """
    :param update_interval_secs: token 缓存时间，单位为秒，默认 180 秒
    :type update_interval_secs: int
    """

    def __init__(self, update_interval_secs=180):
        self._cache = Cache()
        self._last_update_time = 0
        self._token_key = "token_string"
        self.update_interval_secs = update_interval_secs

        self.token_path = os.getenv("SEC_TOKEN_PATH", None)
        self.get_token_from_daemon = os.getenv("GET_SEC_TOKEN_STRING_FROM_DAEMON", None) == "1"
        self.infsec_psm = os.getenv("INFSEC_SEC_PSM", "")
        self.infsec_user = os.getenv("INFSEC_SEC_USER", "")

    def get_token(self, force_update=False):
        """
        从当前环境中获取 DPS token。

        :param force_update: 如果值为真，忽略缓存时间，强制获取并刷新新的 token
        :type force_update: bool
        :return: DPS token
        :rtype: str
        """
        token_string = os.getenv("SEC_TOKEN_STRING", None)
        if token_string is not None:
            return token_string

        now = time.time()
        if force_update or now - self._last_update_time > self.update_interval_secs:
            self._fresh()

        return self._cache.get(self._token_key)

    def _fresh(self):
        try:
            if self.token_path is not None:
                token = self._get_from_file()
            elif self.get_token_from_daemon and (self.infsec_psm or self.infsec_user):
                token = self._get_from_agent()
            else:
                raise DpsError("can not get token, token_path or get_token_from_daemon required")

            if token:
                self._cache.put(self._token_key, token)
                self._last_update_time = time.time()
        except Exception as ex:
            logger.warning("fresh failed, ex is %s" % ex)

    def _get_from_file(self):
        with open(self.token_path) as f:
            data = f.read()
            token_string = data.strip()
            return token_string

    def _get_from_agent(self):
        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        sock.settimeout(0.3)
        try:
            sock.connect(UNIX_DOMAIN_SOCKET_PATH)
        except socket.error:
            logger.warning("fail to connect to unix domain socket!")
            raise

        req = json.dumps({"cmd": 1, "psm": self.infsec_psm, "user": self.infsec_user})
        try:
            sock.sendall(req.encode("utf-8") + b"\n")
            data = sock.recv(2048)
            data = data.decode("utf-8")
            return data.split("\n")[0]

        except Exception as ex:
            logger.warning("get from agent failed, ex is %s", ex)
            raise
        finally:
            sock.close()

    def parse_token(self, token):
        """
        解析 token 的值并返回结构化数据。

        :param token: DPS token
        :type token: str
        :return: 结构化的 token 数据
        :rtype: identity.Identity
        :raises errors.DpsError: token 数据格式错误时抛出
        """
        try:
            claims = jwt.decode(token, verify=False, options={"verify_signature": False})
            if is_token_jwt_svid(token):
                zti = ZeroTrustIdentity().map2identity(claims)
                return zti.get_legacy_identity_from_zti()
            else:
                return Identity(**claims)
        except Exception as ex:
            raise DpsError(ex)