#!/usr/bin/python3
import json
import re
import socket
import asyncio
import subprocess
import threading
import time
from typing import Dict, List, Optional, Union
from datetime import datetime
from my_log import get_logger
import socket
import time
import threading
import select
log = get_logger()


MOCK_LMUTIL = True
if MOCK_LMUTIL:
    from mock_lmutil import *

DISPATCHER_SERVER_PORT = 8809

class LicenseDispatcher:
    def __init__(self, host='0.0.0.0', port=DISPATCHER_SERVER_PORT):
        self.host = host
        self.port = port
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind((self.host, self.port))
        self.server_socket.listen(5)
        self.inputs = [self.server_socket]  # all socket to listen
        self.outputs = []  # all socket to write
        self.message_queues = {}  # store message to send
        self.lock = threading.Lock()
        self.wait_queue = Queue()
        self.exit_event = threading.Event()
        self.loop_thread = threading.Thread(target=self.loop)
        self.loop_thread.start()

    def exit(self):
        self.exit_event.set()
        self.loop_thread.join()

    def loop(self):
        log.info(f"dispatcher server start, listen {self.host}:{self.port}")
        while not self.exit_event.is_set():
            # select listen all socket read/write event
            readable, writable, exceptional = select.select(self.inputs, self.outputs, self.inputs, 1)
            # handle readable socket
            for sock in readable:
                if sock is self.server_socket:
                    # new client connect
                    self._handle_new_connection()
                else:
                    # handle client data
                    self._handle_client_data(sock)
            # handle writable socket
            for sock in writable:
                self._handle_client_response(sock)
            # handle exception socket
            for sock in exceptional:
                self._handle_socket_exception(sock)
            # clean inactive client
            self._cleanup_inactive_clients()
        log.debug("LicenseDispatcher exit")

    def _handle_new_connection(self):
        with self.lock:
            client_socket, address = self.server_socket.accept()
            log.info(f"new client connect: {address}")
            client_socket.setblocking(0)
            self.inputs.append(client_socket)
            self.message_queues[client_socket] = []

    def _handle_client_data(self, sock):
        try:
            data = sock.recv(1024)
            if not data:
                return
            log.trace(f"recv data: {data}")
            try:
                req = json.loads(data.decode('utf-8'))
            except json.JSONDecodeError:
                log.error(f"Invalid JSON data received: {data}")
                self._close_connection(sock)
                return
            req_type = req.get('type', None)
            if req_type == 'heartbeat':
                self._handle_heartbeat(sock, req)
            elif req_type == 'lic_received_ack':
                self._handle_lic_received_ack(req)
        except Exception as e:
            log.error(f"handle client data error: {e}")
            self._close_connection(sock)

    def _handle_heartbeat(self, sock, req):
        """ 心跳包内容
            {
                "type":"heartbeat",
                "user":"",
                "host":"",
                "heartbeat_time":datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
        """
        for item in self.wait_queue:
            if item['user'] == req['user']:
                item['sock'] = sock
                item['heartbeat_time'] = datetime.now()
                break
        else:
            log.warning(f"user {req['user']} not in wait queue")
            sock.close()
            return
        # 如果用户已经分配到license，则直接返回
        if item['lic'] != '':
            self.send_lic_dispatch(item)
            return
        response = {
            'type':'heartbeat_ack',
            'status': 'ok',
            'heartbeat_time': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
        with self.lock:
            self.message_queues[sock].append(json.dumps(response))
            if sock not in self.outputs:
                self.outputs.append(sock)

    def _handle_lic_received_ack(self, req):
        self._remove_user(req['user'])

    def _handle_client_response(self, sock):
        try:
            with self.lock:
                if sock in self.message_queues and self.message_queues[sock]:
                    next_msg = self.message_queues[sock].pop(0)
                    sock.send(next_msg.encode('utf-8'))
                else:
                    self.outputs.remove(sock)
        except Exception as e:
            log.error(f"send response error: {e}")
            self._close_connection(sock)

    def _handle_socket_exception(self, sock):
        log.error(f"handle exception socket: {sock}")
        self._close_connection(sock)

    def _remove_user(self, user):
        with self.lock:
            for idx, item in enumerate(self.wait_queue):
                if item['user'] != user:
                    continue
                self.wait_queue.remove(idx)
                self._close_connection(item['sock'])
                break

    def _close_connection(self, sock):
        if not sock:
            return
        with self.lock:
            # 先从所有列表中移除socket
            if sock in self.outputs:
                self.outputs.remove(sock)
            if sock in self.inputs:
                self.inputs.remove(sock)
            if sock in self.message_queues:
                del self.message_queues[sock]
        try:
            sock.shutdown(socket.SHUT_RDWR)  # 先关闭连接
        except:
            pass  # 忽略已关闭socket的错误
        finally:
            sock.close()  # 最后关闭socket

    def _cleanup_inactive_clients(self, timeout=3):
        """clean inactive client"""
        current_time = datetime.now()
        remove_list = []
        with self.lock:
            for idx, item in enumerate(self.wait_queue):
                if (current_time - item['heartbeat_time']).total_seconds() < timeout:
                    continue
                log.info(f"clean inactive client: {item['user']}")
                remove_list.append(item['user'])
        for user in remove_list:
            self._remove_user(user)

    def add_wait_queue(self, user, host):
        data = {
            "user":user,
            "host":host,
            'status':'wait_dispatch',
            "start_time":datetime.now(),
            'heartbeat_time':datetime.now(),
            'lic':'',
            'sock':None
        }
        with self.lock:
            self.wait_queue.put(data)

    def dispatch_license(self, lic, available_cnt):
        """
        分配license存在几种情况：
        1. 该用户在等待队列中且没有分配到license，那么就直接分配
        2. 该用户在等待队列中且已经分配到license，那么就跳过
        3. 该lic已经被用户占用了，但是这个用户还没有连接，lic处于已经预分配状态，所以也不能再派发给别人
        """
        resp_list = []
        with self.lock:
            for item in self.wait_queue:
                if available_cnt <= 0:
                    break
                if item['lic'] == lic: # 如果该lic已经被分配了，可用数量减1
                    available_cnt -= 1
                    continue
                if item['status'] != 'wait_dispatch': # 如果该用户无需进行分配，则跳过
                    continue
                if item['lic'] != '': # 如果该用户已经分配了，则本次分配跳过
                    continue
                item['lic'] = lic
                item['status'] = 'dispatched'
                resp_list.append(item)
                available_cnt -= 1
        for item in resp_list:
            self.send_lic_dispatch(item)

    def send_lic_dispatch(self, item):
        sock = item['sock'] #如果sock不存在说明该用户还没连接，等待其连接后再发送lic
        if not sock:
            return
        response = {
            'user':item['user'],
            'host':item['host'],
            'lic':item['lic'],
            'type':'lic_dispatch',
            'status': 'ok',
            'msg':f'{item["user"]} get {item["lic"]} license'
        }
        with self.lock:
            self.message_queues[sock].append(json.dumps(response))
            if sock not in self.outputs:
                self.outputs.append(sock)


def _get_ip_address(domain):
    if MOCK_LMUTIL:
        return mock_ipaddress(domain)
    try:
        ip_address = socket.gethostbyname(domain)
        return ip_address
    except socket.gaierror as e:
        log.error(f"get ip address {domain} error: {e}")
        return None

def _get_valid_licenses():
    lic_id = 0
    while True:
        lic_id += 1
        domain = f"szmaslic{lic_id:02d}"
        if _get_ip_address(domain) is None:
            break
        yield "27003@" + domain

class UsedInfo:
    def __init__(self):
        self.user = ''
        self.host = ''
        self.lic = ''
        self.start_time:datetime = None
    def __str__(self):
        obj = self.as_dict()
        return str(obj)
    def __repr__(self):
        return self.__str__()
    def as_dict(self):
        time = datetime.now() - self.start_time
        login_time = (time.days * 24 + time.seconds / 3600.0)
        return {
            "user":self.user,
            "host":self.host,
            "lic":self.lic,
            "login":f'{login_time:.2f}h'
        }

class LicenseInfo:
    def __init__(self, name: str = '', total: int = 0, used: int = 0):
        self.name = name
        self.total = total
        self.used = used
        self.used_info:List[UsedInfo] = []

    def available(self):
        return self.total - self.used

    def __str__(self):
        obj = self.as_dict()
        return str(obj)
    def __repr__(self):
        return self.__str__()

    def as_dict(self):
        info = []
        for used in self.used_info:
            info.append(used.as_dict())
        return {
            "name":self.name,
            "total":self.total,
            "used":self.used,
            "used_info":info
        }

class Queue:
    def __init__(self):
        self.queue = []  # 使用列表作为底层存储
        self.lock = threading.Lock()  # 创建一个锁

    def put(self, item):
        with self.lock:
            self.queue.append(item)  # 添加元素到队列

    def pop(self):
        with self.lock:
            if not self.is_empty():
                return self.queue.pop(0)  # 从队列头部移除并返回元素
            else:
                return None  # 如果队列为空，返回None
    def get(self, idx):
        with self.lock:
            if not self.is_empty():
                return self.queue[idx]
            else:
                return None
    def __getitem__(self, idx):
        with self.lock:
            return self.queue[idx]
    def is_empty(self):
        with self.lock:
            return len(self.queue) == 0  # 检查队列是否为空

    def qsize(self):
        with self.lock:
            return len(self.queue)  # 返回队列大小

    def remove(self, idx):
        with self.lock:
            if 0 <= idx < len(self.queue):
                return self.queue.pop(idx)
            return None

class LicenseManager:
    def __init__(self):
        self.licenses_stat = LicenseStatistic()
        self.licenses:Dict[str,LicenseInfo] = {}
        self.dispatcher = LicenseDispatcher()
        self.exit_event = threading.Event()
        self.timer = None
        self.start_updater()  # 替换原来的线程启动

    def start_updater(self):
        if not self.exit_event.is_set():
            self.update_once()
            # 设置下一次执行
            self.timer = threading.Timer(5.0, self.start_updater)
            self.timer.start()

    def update_once(self):
        """单次更新操作"""
        self.licenses_stat.update()
        if self.dispatcher.wait_queue.qsize() > 0:
            for lic, available_cnt, _ in self.licenses_stat.available():
                self.dispatcher.dispatch_license(lic, available_cnt)

    def request(self, user: str, host: str) -> Dict[str, Union[str, dict]]:
        #如果已经是在线的状态就不允许申请
        rep = {
                "user":user,
                "host":host,
                "status":"refuse",
                "lic":'',
                "msg":f"unknown error"
        }
        if self.dispatcher.wait_queue.qsize() > 100:
                rep["status"] = "refuse"
                rep["msg"] = f"{user} queue is full!!"
                return rep
        if user in self.licenses_stat.online_users():
            rep["msg"] = f"{user} is online"
            log.warning(rep["msg"])
            return rep

        #如果是已经在队列中则返回等待
        item = next((item for item in self.dispatcher.wait_queue if item['user'] == user), None)
        if item:
            rep["status"] = "queue"
            rep["msg"] = f"{user} is in queue!!"
            rep["start_time"] = item['start_time'].strftime("%Y-%m-%d %H:%M:%S")
            return rep
        log.info(f"add {user} to wait queue")
        # 如果队列为空，则直接分配一个license
        if self.dispatcher.wait_queue.qsize() == 0:
            self.dispatcher.add_wait_queue(user, host)
            lic, available_cnt, _ = next(self.licenses_stat.available(), ('', 0, 0))
            self.dispatcher.dispatch_license(lic, available_cnt)
        else:
            self.dispatcher.add_wait_queue(user, host)
        rep["status"] = "wait_dispatch"
        rep["msg"] = f"{user} add to queue"
        rep["dispatcher_server"] = {
            "port": DISPATCHER_SERVER_PORT
        }
        return rep

    def get_wait_queue(self):
        resp = []
        for item in self.dispatcher.wait_queue:
            resp.append({
                "user":item['user'],
                "host":item['host'],
                "status":item['status'],
                "wait_time":int((datetime.now() - item['start_time']).total_seconds())
            })
        return resp

    def get_licenses_info(self):
        resp = {}
        for lic, info in self.licenses_stat.licenses.items():
            info  = info.as_dict()
            resp[lic] = info
        return resp

    def exit(self):
        self.exit_event.set()
        if self.timer:
            self.timer.cancel()
        self.timer = None
        if self.dispatcher:
            self.dispatcher.exit()

class LicenseStatistic:
    def __init__(self):
        self.licenses:Dict[str,LicenseInfo] = {}

    def update(self):
        # 更新license信息，使用异步获取
        tasks = []
        for lic in _get_valid_licenses():
            log.trace(f'find valid lic: {lic}')
            tasks.append(get_license_used_info(lic))
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        try:
            infos = loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
            for info in infos:
                if info is None:
                    continue
                if not isinstance(info, LicenseInfo):
                    log.error(f"get_license_used_info {info} is not LicenseInfo")
                    continue
                self.licenses[info.name] = info
            if not self.licenses:
                log.warning("not vcast lic found")
        except Exception as e:
            log.error(f"update license info error: {e}")
        loop.close()

    def get_lic_list(self):
        # 获取所有的license名称
        return self.licenses.keys()

    def available(self):
        # 获取所有的可用数量
        for _,lic in self.licenses.items():
            value = lic.available()
            if value > 0:
                yield (lic.name, value, lic.total) #lic的name和个数

    def online_users(self):
        # 获取在线用户
        for used_info in self.used():
            yield used_info.user #返回的是user name

    def used(self):
        # 获取所有的已使用信息
        for _,info in self.licenses.items():
            for used in info.used_info:
                yield used #返回的是UsedInfo对象

    def sorted(self):
        info = {}
        for used_info in self.used():
            time = datetime.now() - used_info.start_time
            login_time = (time.days * 24 + time.seconds / 3600.0)
            info[used_info.user] = login_time
        sorted_info = dict(sorted(info.items(), key=lambda item: item[1], reverse=True))
        return sorted_info #返回的是字典，key为username value为登录时间

    def __str__(self):
        string = str(self.licenses).replace("'", '"')
        log.info(string)
        obj = json.loads(string)
        string = json.dumps(obj, indent = 4)
        return string
    def __repr__(self):
        return self.__str__()


def shell(cmd, checkret=True):
    if MOCK_LMUTIL:
        ret = mock_lmutil(cmd)
        if not ret:
            return 1, '', ''
        return 0, ret, ''
    process = subprocess.Popen(cmd,
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE,
                             universal_newlines=True)
    out, err = process.communicate()
    ret = process.returncode
    if checkret and ret != 0:
        raise subprocess.CalledProcessError(ret, cmd, output=out, stderr=err)
    return ret, out, err

"""
  {"27003@szmaslic03": {"name": "27003@szmaslic03", "total": 2, "used": 1, "used_info": "[{"name": "haoxiang.ran", "host": "szl3bc12808", "lic": "szmaslic03", "login": "0.41"}]"}, "27003@szmaslic04": {"name": "27003@szmaslic04", "total": 2, "used": 1, "used_info": "[{"name": "macro.yang", "host": "szl3bc12804", "lic": "szmaslic04", "login": "52.28"}]"}, "27003@szmaslic06": {"name": "27003@szmaslic06", "total": 2, "used": 2, "used_info": "[{"name": "zhenhao.he", "host": "szl3bc12804", "lic": "szmaslic06", "login": "0.20"}, {"name": "phillip.chan", "host": "szl3bc12810", "lic": "szmaslic06", "login": "0.16"}]"}, "27003@szmaslic07": {"name": "27003@szmaslic07", "total": 2, "used": 1, "used_info": "[{"name": "zhiyi.li", "host": "szl3bc12806", "lic": "szmaslic07", "login": "2.96"}]"}, "27003@szmaslic08": {"name": "27003@szmaslic08", "total": 2, "used": 2, "used_info": "[{"name": "soo.liu", "host": "szl3bc12809", "lic": "szmaslic08", "login": "6.55"}, {"name": "haichao.ou", "host": "szl3bc12806", "lic": "szmaslic08", "login": "5.93"}]"}, "27003@szmaslic09": {"name": "27003@szmaslic09", "total": 2, "used": 2, "used_info": "[{"name": "louie.liang", "host": "szl3bc12810", "lic": "szmaslic09", "login": "8.31"}, {"name": "zabbix", "host": "szl3bc06409", "lic": "szmaslic09", "login": "0.90"}]"}, "27003@szmaslic10": {"name": "27003@szmaslic10", "total": 2, "used": 2, "used_info": "[{"name": "harvey.li", "host": "szl3bc12810", "lic": "szmaslic10", "login": "57.38"}, {"name": "kw.hu", "host": "szl3bc12809", "lic": "szmaslic10", "login": "1.41"}]"}}
"""
async def get_license_used_info(lic):
    # log.info(f"get_license_used_info {lic}")
    server_used_info = f"timeout 1 /tools/software/vcast/flexlm/lmutil lmstat -a -c {lic}"
    ret,out,err = shell(server_used_info, checkret=False)
    # log.info(f"get_license_used_info {lic} {out} {ret} {err}")
    if ret != 0:
        return None
    """ data like:
    Users of VCAST_C_ENT_0800:  (Total of 2 licenses issued;  Total of 2 licenses in use)

    "VCAST_C_ENT_0800" v23, vendor: vector, expiry: permanent(no expiration date)
    vendor_string: CUST:64925:
    floating license

        zhenhao.he szl3bc12804 /dev/tty (v23) (szmaslic06/27003 337), start Thu 1/2 8:52
        phillip.chan szl3bc12810 /dev/tty (v23) (szmaslic06/27003 233), start Thu 1/2 14:59

    Users of CCAST_0801:  (Total of 2 licenses issued;  Total of 0 licenses in use)

    """
    status = 'idle'
    info = LicenseInfo(lic)
    for line in out.splitlines():
        line = line.strip()
        if status == 'idle':
            #Error getting status: Cannot find license file. (-1,359:2 "No such file or directory")
            if line.startswith("Error getting status"):
                log.warning(f"{lic}")
                return None
            if not line.startswith("Users of VCAST_C_ENT_0800:"):
                continue
            status = 'start'
            #[Users of VCAST_C_ENT_0800:  (Total of 2 licenses issued;  Total of 1 license in use)
            pattern = r"\(Total of (\d+).*Total of (\d+).*\)"
            ret = re.findall(pattern, line)
            if not ret:
                log.warning(f"{lic} parser [{line}] fail")
                return info
            (total, used) = ret[0]
            info.total = int(total)
            info.used = int(used)
        elif status == 'start':
            #zhenhao.he szl3bc12804 /dev/tty (v23) (szmaslic06/27003 337), start Thu 1/2 8:52
            pattern = '(\S+) (\S+).*\((\S+)/.*\), start (.*)'
            ret = re.findall(pattern, line)
            if not ret:
                continue
            used = UsedInfo()
            (used.user,used.host,used.lic,time_string) = ret[0]
            #处理跨年的情况
            year = datetime.now().year
            start_time = datetime.strptime(f"{year} {time_string}", "%Y %a %m/%d %H:%M")
            if start_time > datetime.now():
                year -= 1
                start_time = datetime.strptime(f"{year} {time_string}", "%Y %a %m/%d %H:%M")
            used.start_time = start_time
            # log.info(f"{lic} => {used}")
            info.used_info.append(used)
        # Next section
        elif line.startswith('Users of '):
            break
    return info

def draw_time_grpah(license_manager):
    info = license_manager.sorted()
    max_time = max(info.values())
    name_len = max([len(_) for _ in info.keys()])
    top = 100
    for user, time in info.items():
        curr = '█' * max(int(top * time / max_time), 1)
        name_remain = ' ' * (name_len - len(user))
        log.info(f"{user}{name_remain} :{time:5.2f}h {curr}")

if __name__ == '__main__':
    log.info("License status query...")
    lm = LicenseStatistic()
    log.info(lm)
    log.info(f"All licenses is: {[str(_) for _ in lm.get_lic_list()]}")
    for lic,number,total in lm.available():
        log.info(f"{lic}: {number} lic available")
    draw_time_grpah(lm)