import os
import base64
import socket
from functools import lru_cache, wraps
from typing import Union

import json
import time
import math
import datetime
import platform
import subprocess
import ntpath


def compute_last_time(time1, ctime):
    """计算time1与当前时间的差值，转换为D H M S格式"""

    day, hour, mins, sec = 0, 0, 0, 0
    dt1 = datetime.datetime.strptime(str(time1), '%Y-%m-%d %H:%M:%S')
    dt2 = datetime.datetime.strptime(str(ctime), '%Y-%m-%d %H:%M:%S')
    diff_str = str(dt2 - dt1)
    if diff_str == '0:00:00':
        return '0秒'
    # 时、分、秒用小写字母h、m、s，天用大写字母D
    if 'day' not in diff_str:
        sec, mins, hour = list(map(int, diff_str.split(":")))[::-1]
    else:
        day = diff_str.split(',')[0].split(' ')[0]
        sec_min_hour = diff_str.split(",")[1].strip().split(":")
        sec, mins, hour = list(map(int, sec_min_hour))[::-1]

    day = int(day)
    all_time = (F'{day}天', F'{hour}时', F'{mins}分', F'{sec}秒')
    # 处理为仅仅两个单位，找到第一个非0的单位，取两个值即可
    start = 0
    for i, e in enumerate(all_time):
        if int(e[:-1]) != 0:
            start = i
            break
    real_time_str = ' '.join(all_time[start : start + 2])
    return real_time_str


def is_today_time(time1):
    """判断是否今天内发生的"""

    today = str(datetime.datetime.today()).split(' ')[0] + ' 0:0:0'
    dt1 = datetime.datetime.strptime(str(time1), '%Y-%m-%d %H:%M:%S')
    dt2 = datetime.datetime.strptime(today, '%Y-%m-%d %H:%M:%S')
    diff_str = str(dt1 - dt2)
    if 'day' in diff_str:
        return False, time1
    else:
        return True, time1.split(' ')[1]


def time_convert(s: int) -> str:
    """
    秒转化为
    :param s: int 秒
    :return: str  转化后的时间， 数据加单位
    """
    m, s = divmod(s, 60)

    if not m:
        return F"{s}秒"

    h, m = divmod(m, 60)

    if not h:
        return F"{m}分{s}秒"

    d, h = divmod(h, 24)

    if not d:
        return F"{h}时{m}分"

    return F"{d}天{h}时"


def time_convert_2_list(s: int) -> list:
    """
    秒转化为
    :param s: int 秒
    :return: list  list[0]转化后的时间，list[1]数据单位
    """
    m, s = divmod(s, 60)

    if not m:
        return [s, "秒"]

    h, m = divmod(m, 60)

    if not h:
        return [m, "分"]

    d, h = divmod(h, 24)

    if not d:
        return [h, "时"]

    ten, d = divmod(d, 10)

    if not ten:
        return [d, "天"]

    return [10, "天+"]


def byte_convert_2_kb(s):
    """
    秒转化为
    :param s: int byte
    :return: float kb
    """
    return round(float(s) / 1024, 3)


def ms_2_s(s):
    """
    毫秒转为秒
    """
    return int(round(float(s) / 1000, 0))


def bytes_to_tb(bytes: int) -> Union[int, float]:
    tb = bytes / (1024**4)
    tb_rounded = round(tb, 2)
    if tb_rounded.is_integer():
        return int(tb_rounded)
    else:
        return tb_rounded


class lazyproperty:
    """惰性属性"""

    def __init__(self, fun):
        self.fun = fun

    def __get__(self, instance, owner):
        if instance is None:
            return self
        value = self.fun(instance)
        setattr(instance, self.fun.__name__, value)
        return value


def ping_connect(ip, retry=1):
    """ping测试"""
    system = platform.system()
    cmd = f'ping -n 1 -w 1 {ip}' if system == 'Windows' else f'ping -c 3 {ip}'
    return_code = -1
    for i in range(retry):
        with subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE) as p:
            p.wait()
            if p.returncode == 0:
                return_code = p.returncode
                break
        time.sleep(1)
    return return_code == 0


def Singleton(cls):
    """单例模式"""
    _instance = {}

    def inner():
        if cls not in _instance:
            _instance[cls] = cls()
        return _instance[cls]

    return inner


class SingletonArguments(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(SingletonArguments, cls).__call__(*args, **kwargs)
        return cls._instances[cls]


def str2int(v):
    try:
        return int(v)
    except Exception:
        return v


def bytes2str(v):
    try:
        if isinstance(v, bytes):
            return v.decode('utf8')
    except Exception:
        return v


def int2timestr(v):
    try:
        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(v / 1000))
    except Exception as msg:
        return v


def int2datetime(v):
    try:
        return datetime.datetime.fromtimestamp(v / 1000)
    except Exception as msg:
        return v


def str2datetime(v):
    try:
        return datetime.datetime.strptime(v, '%Y-%m-%s %H:%M:%S')
    except Exception as msg:
        return datetime.datetime.now()


def str2float(v):
    try:
        return float(v)
    except Exception:
        return v


def upper(v):
    try:
        return v.upper()
    except Exception:
        return v


def lower(v):
    try:
        return v.lower()
    except Exception:
        return v


def basename(path):
    """获取路径的文件名"""
    return ntpath.basename(path)


def yanei_decimal(value: float, num: int):
    """保留num位有效数字

    :param value:float: 待处理浮点数
    :param num:int: 有效位数
    """
    try:
        if not isinstance(value, float):
            return value
        s = str(value)
        pre, post = s.split('.')
        return float(pre + '.' + post[:num])
    except Exception:
        return value


def seconds_format(time_cost: int):
    """
    耗费时间格式转换
    :param time_cost:
    :return:
    """
    min_value = 60
    hour = 60 * 60
    day = 60 * 60 * 24
    if not time_cost or time_cost < 0:
        return '0秒'
    elif time_cost < min_value:
        return '%s秒' % int(time_cost)
    elif time_cost < hour:
        #  return '%s分%s秒' % (divmod(time_cost, min_value))
        return '%s分%s秒' % (divmod(int(time_cost), int(min_value)))
    elif time_cost < day:
        cost_hour, cost_min = divmod(int(time_cost), int(hour))
        if cost_min > min_value:
            return '%s时%s' % (int(cost_hour), seconds_format(cost_min))
        else:
            return '%s时0分%s' % (int(cost_hour), seconds_format(cost_min))
    else:
        cost_day, cost_hour = divmod(int(time_cost), int(day))
        if cost_hour >= hour:
            return '%s天%s' % (int(cost_day), seconds_format(cost_hour))
        elif cost_hour >= min_value:
            return '%s天0时%s' % (int(cost_day), seconds_format(cost_hour))
        else:
            return '%s天0时0分%s' % (int(cost_day), seconds_format(cost_hour))


def calculate_rto(end, start, ceil=True):
    """其中end, start都是ms级别的时间戳, ceil表示是否向上取整"""
    total_miscro = float(end - start)
    if ceil:
        total = math.ceil(total_miscro / 1000)
    else:
        if total_miscro < 1000:
            total = math.ceil(total_miscro / 1000)
        else:
            total = int(total_miscro / 1000)
    return seconds_format(total)


def transform_duration_str_to_seconds(duration_str: str):
    """
    将时长字符串转换为秒
    :param duration_str: 时长字符串 eg: 1天2时3分4秒
    :return:
    """
    if not duration_str:
        return None

    try:
        day, hour, minute, second = 0, 0, 0, 0
        if "天" in duration_str:
            _values = duration_str.split("天", 1)
            day = int(_values[0])
            duration_str = _values[-1]

        if "时" in duration_str:
            _values = duration_str.split("时", 1)
            hour = int(_values[0])
            duration_str = _values[-1]

        if "分" in duration_str:
            _values = duration_str.split("分", 1)
            minute = int(_values[0])
            duration_str = _values[-1]

        if "秒" in duration_str:
            _values = duration_str.split("秒", 1)
            second = int(duration_str.split("秒")[0])

        return day * 24 * 60 * 60 + hour * 60 * 60 + minute * 60 + second
    except Exception:
        return None


def extra_script_data_after_call(resp):
    """解析内容部门返回的响应数据并拼接成字符串"""
    resp_data = ''
    try:
        overall = resp.get('overall')
        _ts = resp.get('data', [])
        resp_data = f'状态码:{overall} 其他信息:'
        if isinstance(_ts, list):
            for _t in _ts:
                resp_data += f'{_t}\n'
    except Exception:
        try:
            resp_data = f'{resp}'
        except:
            pass
    return resp_data


def time_diff_int(str_time1, str_time2):
    """计算差值，返回秒数"""
    # TODO 修改类型
    if str(str_time2) == '2038-01-01 00:00:00':
        raise Exception()
    timearray = time.strptime(str_time1, "%Y-%m-%d %H:%M:%S")
    int_time1 = int(time.mktime(timearray))
    timearray = time.strptime(str_time2, "%Y-%m-%d %H:%M:%S")
    int_time2 = int(time.mktime(timearray))
    return int_time1 - int_time2


def timed_lru_cache(seconds: int, maxsize: int = 128):
    def wrapper_cache(func):
        func = lru_cache(maxsize=maxsize)(func)
        func.lifetime = datetime.timedelta(seconds=seconds)
        func.expiration = datetime.datetime.now() + func.lifetime

        @wraps(func)
        def wrapped_func(*args, **kwargs):
            if datetime.datetime.now() >= func.expiration:
                func.cache_clear()
                func.expiration = datetime.datetime.now() + func.lifetime

            return func(*args, **kwargs)

        return wrapped_func

    return wrapper_cache


def is_illegal_name(name):
    illegal_list = ['+', "-", "=", "@"]
    for i in illegal_list:
        if i in name:
            return True

    return False


def get_local_ip():
    try:
        # 获取本机主机名
        hostname = socket.gethostname()
        # 获取本机IP地址
        ip_address = socket.gethostbyname(hostname)
        return ip_address
    except socket.error:
        return "Unable to get local IP"