import threading
import json
import re
from tools import get_all_data, generate_subscription_links
from xuiapi import getSession, get_server_status, get_inbound_list
from tqdm import tqdm


def start(url):
    ip_pattern = r"\b(?:\d{1,3}\.){3}\d{1,3}\b"
    server_obj = {
        "xrayState": False,  # xray状态
        "xrayVersion": "",  # xray 版本号
        "uptime": "",  # 运行时间
        "sent": "",  # 上行总流量
        "recv": "",  # 下行总流量
        "link": "",  # 连接
        "expiry": "",  # 到期时间
        "traffic": "",  # 流量限制
    }
    try:
        session = getSession(url)
        type = get_server_status(url, session)
        if type is None:
            return server_obj
        sent, recv, state, version = get_all_data(type=type)
        server_obj["recv"] = recv
        server_obj["sent"] = sent
        server_obj["xrayState"] = state
        server_obj["xrayVersion"] = version

        if "appStats" in type["obj"]:
            pass
        else:
            inboundList = get_inbound_list(url, session)
            links, expiry_times, traffic_limits = generate_subscription_links(
                inboundList, re.search(ip_pattern, url).group()
            )
            server_obj["link"] = links
            server_obj["expiry"] = expiry_times
            server_obj["traffic"] = traffic_limits
        return server_obj
    except Exception as err:
        return server_obj


def process_ips(ip_list, endArray, pbar):
    for ip in ip_list:
        result = start(ip)
        endArray.append(result)
        pbar.update(1)


def main():
    with open("./ips.txt") as f:
        ips = f.read().splitlines()

    endArray = []
    threads = []
    num_threads = 2
    ips_per_thread = len(ips) // num_threads

    # 创建一个进度条
    pbar = tqdm(total=len(ips), desc="Processing IPs")

    for i in range(num_threads):
        start_index = i * ips_per_thread
        if i == num_threads - 1:  # Make sure the last thread gets any remaining IPs
            end_index = len(ips)
        else:
            end_index = (i + 1) * ips_per_thread
        ip_subset = ips[start_index:end_index]
        thread = threading.Thread(target=process_ips, args=(ip_subset, endArray, pbar))
        threads.append(thread)
        thread.start()

    for thread in threads:
        thread.join()

    pbar.close()

    with open("./output.json", "w") as f:
        json.dump(endArray, f, indent=4)


if __name__ == "__main__":
    main()

import json
import base64
import urllib.parse


def convert_bytes_to_readable_unit(bytes_value):
    """将字节值转换为可读单位（MB、GB、TB）。"""
    GB = 1073741824
    TB = 1099511627776
    MB = 1048576

    if bytes_value >= TB:
        return f"{bytes_value / TB:.2f} TB"
    elif bytes_value >= GB:
        return f"{bytes_value / GB:.2f} GB"
    else:
        return f"{bytes_value / MB:.2f} MB"


def get_all_data(type):
    if "netTraffic" in type["obj"]:
        sent = convert_bytes_to_readable_unit(type["obj"]["netTraffic"]["sent"])
        recv = convert_bytes_to_readable_unit(type["obj"]["netTraffic"]["recv"])
    if "xray" in type["obj"]:
        state = type["obj"]["xray"]["state"]
        version = type["obj"]["xray"]["version"]

    return sent, recv, state, version


def generate_subscription_links(data, ip_address):
    links = []
    expiry_times = []
    traffic_limits = []

    if data["success"]:
        for item in data["obj"]:
            if item["enable"]:
                protocol = item["protocol"]
                prot = item["port"]
                link = ""
                if protocol == "vless":
                    settings = json.loads(item["settings"])
                    client_id = settings["clients"][0]["id"]
                    flow = settings["clients"][0].get("flow", "")
                    stream_settings = json.loads(item["streamSettings"])
                    network = stream_settings["network"]
                    security = stream_settings["security"]
                    ws_settings = stream_settings.get("wsSettings", {})
                    path = ws_settings.get("path", "/")
                    query = f"type={network}&security={security}&path={urllib.parse.quote(path)}"
                    if flow:
                        query += f"&flow={flow}"
                    link = f"{protocol}://{client_id}@{ip_address}:{prot}?{query}"
                elif protocol == "vmess":
                    settings = json.loads(item["settings"])
                    client_id = settings["clients"][0]["id"]
                    stream_settings = json.loads(item["streamSettings"])
                    network = stream_settings["network"]
                    ws_settings = stream_settings.get("wsSettings", {})
                    path = ws_settings.get("path", "/")
                    vmess_config = {
                        "v": "2",
                        "ps": item["tag"],
                        "add": ip_address,
                        "port": item["port"],
                        "id": client_id,
                        "aid": "0",
                        "net": network,
                        "type": "none",
                        "host": "",
                        "path": path,
                        "tls": "",
                    }
                    link = f"vmess://{base64.urlsafe_b64encode(json.dumps(vmess_config).encode()).decode().strip('=')}"
                elif protocol == "trojan":
                    settings = json.loads(item["settings"])
                    client_id = settings["clients"][0]["password"]
                    link = f"trojan://{client_id}@{ip_address}:{prot}"
                elif protocol == "shadowsocks":
                    settings = json.loads(item["settings"])
                    method = settings["method"]
                    password = settings["password"]
                    link = f"ss://{base64.urlsafe_b64encode(f'{method}:{password}@{ip_address}:{prot}'.encode()).decode().strip('=')}"
                elif protocol == "http":
                    settings = json.loads(item["settings"])
                    user = settings["accounts"][0]["user"]
                    password = settings["accounts"][0]["pass"]
                    link = f"{protocol}://{user}:{password}@{ip_address}:{prot}"
                elif protocol == "socks":
                    settings = json.loads(item["settings"])
                    user = settings["accounts"][0]["user"]
                    password = settings["accounts"][0]["pass"]
                    ip = settings["ip"]
                    link = f"{protocol}://{user}:{password}@{ip}:{prot}"

                links.append(link)
                expiry_times.append(item["expiryTime"])
                traffic_limits.append(item["total"])

    return links, expiry_times, traffic_limits

import requests


# 获取 cookie
def getSession(url):
    # 定义请求的表单数据
    data = {"username": "admin", "password": "admin"}

    # 定义请求的头信息
    headers = {
        "Accept": "application/json, text/plain, */*",
        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
    }

    # 发送 POST 请求
    response = requests.post(url + "/login", data=data, headers=headers)

    # 检查响应状态码
    if response.status_code == 200:
        # 获取响应头中的 Set-Cookie 中的 session
        cookies = response.cookies
        session_cookie = cookies.get("session")
        return session_cookie
    else:
        return None


# 获取服务器配置信息 inbound
def get_server_status(url, session_cookie):
    # 定义请求的头信息
    headers = {
        "Accept": "application/json, text/plain, */*",
        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
        "Cookie": f"session={session_cookie}",
    }
    # 发送 POST 请求
    response = requests.post(url + "/server/status", headers=headers)

    # 检查响应状态码
    if response.status_code == 200:
        # 打印返回的 JSON 数据
        return response.json()
    else:
        return None


# 获取节点列表
def get_inbound_list(url, session_cookie):
    # 定义请求的头信息
    headers = {
        "Accept": "application/json, text/plain, */*",
        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
        "Cookie": f"session={session_cookie}",
    }
    # 发送 POST 请求
    response = requests.post(url + "/xui/inbound/list", headers=headers)

    # 检查响应状态码
    if response.status_code == 200:
        # 打印返回的 JSON 数据
        return response.json()
    else:
        return None

import json

# 读取 JSON 文件
with open("./output.json", "r", encoding="utf-8") as file:
    data = json.load(file)


# 函数：将 JSON 转换为 Markdown 表格
def json_to_markdown(json_data):
    headers = [
        "xray状态",
        "xray版本",
        "运行时间",
        "上行总流量",
        "下行总流量",
        "订阅链接",
    ]
    markdown_table = "| " + " | ".join(headers) + " |\n"
    markdown_table += "| " + " | ".join(["---"] * len(headers)) + " |\n"

    for item in json_data:
        xrayState = item.get("xrayState", "")
        xrayVersion = item.get("xrayVersion", "")
        uptime = item.get("uptime", "")
        sent = item.get("sent", "")
        recv = item.get("recv", "")
        link = "<br />".join(item.get("link", []))

        markdown_table += (
            f"| {xrayState} | {xrayVersion} | {uptime} | {sent} | {recv} | {link} |\n"
        )

    return markdown_table


# 将 JSON 数据转换为 Markdown 表格
markdown_table = json_to_markdown(data)

# 输出到文件
with open("output.md", "w", encoding="utf-8") as f:
    f.write(markdown_table)