HeXi/hexi/plugins/nonebot_plugin_steam_info/draw.py

import numpy as np
from functools import lru_cache
from io import BytesIO
from pathlib import Path
from typing import List, Dict, Tuple, Optional
from colorsys import rgb_to_hsv, hsv_to_rgb
from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageEnhance

from .utils import hex_to_rgb
from .models import DrawPlayerStatusData, Achievements, ProfileCardExtra


WIDTH = 400
PARENT_AVATAR_SIZE = 72
MEMBER_AVATAR_SIZE = 50

# 游戏图标与玩家信息的统一水平坐标
GAME_ICON_X = 12
GAME_ICON_SIZE = 26
GAME_NAME_X = GAME_ICON_X + GAME_ICON_SIZE + 12  # 50:图标和游戏/玩家信息对齐点
PLAYER_AVATAR_X = GAME_NAME_X - 2  # 48:头像带边框,内部头像落在 GAME_NAME_X
PLAYER_NAME_X = GAME_NAME_X + MEMBER_AVATAR_SIZE + 18  # 118:玩家昵称/游戏名/状态统一左对齐

unknown_avatar_path = Path(__file__).parent / "res/unknown_avatar.jpg"
parent_status_path = Path(__file__).parent / "res/parent_status.png"
friends_search_path = Path(__file__).parent / "res/friends_search.png"
busy_path = Path(__file__).parent / "res/busy.png"
zzz_online_path = Path(__file__).parent / "res/zzz_online.png"
zzz_gaming_path = Path(__file__).parent / "res/zzz_gaming.png"
gaming_path = Path(__file__).parent / "res/gaming.png"

font_regular_path = None
font_light_path = None
font_bold_path = None


def set_font_paths(regular_path, light_path, bold_path):
    global font_regular_path, font_light_path, font_bold_path
    base_dir = Path().cwd()
    font_regular_path = str((base_dir / regular_path).resolve())
    font_light_path = str((base_dir / light_path).resolve())
    font_bold_path = str((base_dir / bold_path).resolve())


def check_font():
    if not Path(font_regular_path).exists():
        raise FileNotFoundError(f"Font file {font_regular_path} not found.")
    if not Path(font_light_path).exists():
        raise FileNotFoundError(f"Font file {font_light_path} not found.")
    if not Path(font_bold_path).exists():
        raise FileNotFoundError(f"Font file {font_bold_path} not found.")


@lru_cache(maxsize=None)
def get_font(path: str, size: int) -> ImageFont.FreeTypeFont:
    """按 (路径, 字号) 缓存字体，避免每次绘制都重新解析字体文件"""
    return ImageFont.truetype(path, size)


personastate_colors = {
    0: (hex_to_rgb("969697"), hex_to_rgb("656565")),
    1: (hex_to_rgb("6dcef5"), hex_to_rgb("4c91ac")),
    2: (hex_to_rgb("6dcef5"), hex_to_rgb("4c91ac")),
    3: (hex_to_rgb("45778e"), hex_to_rgb("365969")),
    4: (hex_to_rgb("6dcef5"), hex_to_rgb("4c91ac")),
    5: (hex_to_rgb("6dcef5"), hex_to_rgb("4c91ac")),
    6: (hex_to_rgb("6dcef5"), hex_to_rgb("4c91ac")),
}


def avatar_with_border(
    avatar: Image.Image, border_width: int = 2, border_color=(255, 255, 255)
) -> Image.Image:
    """给头像添加边框，返回比原头像大 2*border_width 的图像"""
    width, height = avatar.size
    bordered = Image.new(
        "RGB", (width + border_width * 2, height + border_width * 2), border_color
    )
    bordered.paste(avatar, (border_width, border_width))
    return bordered


def vertically_concatenate_images(images: List[Image.Image]) -> Image.Image:
    widths, heights = zip(*(i.size for i in images))
    total_width = max(widths)
    total_height = sum(heights)

    new_image = Image.new("RGB", (total_width, total_height))

    y_offset = 0
    for image in images:
        new_image.paste(image, (0, y_offset))
        y_offset += image.size[1]

    return new_image


def _truncate_with_ellipsis(
    draw: ImageDraw.ImageDraw, text: str, font, max_width: int
) -> str:
    """将文本按 max_width 省略号截断,返回最终绘制文本"""
    ellipsis = "…"
    truncated = ""
    for ch in text:
        if draw.textlength(truncated + ch + ellipsis, font=font) > max_width:
            break
        truncated += ch
    return truncated + ellipsis


def _fit_name_nick(
    draw: ImageDraw.ImageDraw,
    name: str,
    nickname: str,
    name_font,
    nick_font,
    gap: int,
    max_width: int,
) -> Tuple[str, str]:
    """在 max_width 内排布 [主名][群昵称],返回 (主名绘制文本, 群昵称绘制文本)

    主名优先: 主名过长时省略号截断主名,不再画群昵称;
    主名放得下时,群昵称只取剩余宽度,放不下则返回空串。
    """
    if draw.textlength(name, font=name_font) > max_width:
        return _truncate_with_ellipsis(draw, name, name_font, max_width), ""
    if not nickname:
        return name, ""
    available = max_width - draw.textlength(name, font=name_font) - gap
    if available <= 0:
        return name, ""
    if draw.textlength(nickname, font=nick_font) <= available:
        return name, nickname
    return name, _truncate_with_ellipsis(draw, nickname, nick_font, available)


def draw_start_gaming(
    avatar: Image.Image, friend_name: str, game_name: str, nickname: str = None
):
    canvas = Image.open(gaming_path)
    canvas.paste(avatar.resize((66, 66), Image.BICUBIC), (15, 20))

    # 绘制名称:steam 昵称优先,群昵称小字挂尾,超宽省略号截断,避免画出图片外
    draw = ImageDraw.Draw(canvas)
    name_font = get_font(font_regular_path, 19)
    nick_font = get_font(font_light_path, 13)
    name_drawn, nick_drawn = _fit_name_nick(
        draw, friend_name, nickname or "", name_font, nick_font, 6,
        canvas.width - 104 - 10,
    )
    draw.text((104, 14), name_drawn, font=name_font, fill=hex_to_rgb("e3ffc2"))
    if nick_drawn:
        draw.text(
            (104 + draw.textlength(name_drawn, font=name_font) + 6, 15),
            nick_drawn,
            font=nick_font,
            fill=hex_to_rgb("969696"),
        )

    # 绘制"正在玩"
    draw.text(
        (103, 42),
        "正在玩",
        font=get_font(font_regular_path, 17),
        fill=hex_to_rgb("969696"),
    )

    # 绘制游戏名称
    draw.text(
        (104, 66),
        game_name,
        font=get_font(font_bold_path, 14),
        fill=hex_to_rgb("91c257"),
    )

    return canvas


def draw_parent_status(parent_avatar: Image.Image, parent_name: str) -> Image.Image:
    parent_avatar = parent_avatar.resize(
        (PARENT_AVATAR_SIZE, PARENT_AVATAR_SIZE), Image.BICUBIC
    )

    canvas = Image.open(parent_status_path).resize((WIDTH, 120), Image.BICUBIC)

    draw = ImageDraw.Draw(canvas)

    # 在左下角 (16, 16) 处绘制头像
    avatar_height = 120 - 16 - PARENT_AVATAR_SIZE
    canvas.paste(avatar_with_border(parent_avatar), (14, avatar_height - 2))

    # 绘制名称
    draw.text(
        (16 + PARENT_AVATAR_SIZE + 16, avatar_height + 12),
        parent_name,
        font=get_font(font_bold_path, 20),
        fill=hex_to_rgb("6dcff6"),
    )

    # 绘制状态
    draw.text(
        (16 + PARENT_AVATAR_SIZE + 16, avatar_height + 20 + 16),
        "在线",
        font=get_font(font_light_path, 18),
        fill=hex_to_rgb("4c91ac"),
    )

    return canvas


def draw_friends_search() -> Image.Image:
    canvas = Image.new("RGB", (WIDTH, 50), hex_to_rgb("434953"))

    friends_search = Image.open(friends_search_path)

    canvas.paste(friends_search, (WIDTH - friends_search.width, 0))

    draw = ImageDraw.Draw(canvas)

    draw.text(
        (24, 10),
        "好友",
        hex_to_rgb("b7ccd5"),
        font=get_font(font_regular_path, 20),
    )

    return canvas


def draw_friend_status(
    friend_avatar: Image.Image,
    friend_name: str,
    status: str,
    personastate: int,
    nickname: str = None,
) -> Image.Image:
    friend_avatar = friend_avatar.resize(
        (MEMBER_AVATAR_SIZE, MEMBER_AVATAR_SIZE), Image.BICUBIC
    )

    canvas = Image.new("RGB", (WIDTH, 64), hex_to_rgb("1e2024"))

    draw = ImageDraw.Draw(canvas)

    # 状态图标(忙碌/ZZZ)插在 steam 昵称与群昵称之间,先预留其宽度
    name_font = get_font(font_bold_path, 20)
    nick_font = get_font(font_light_path, 13)
    name_x = 22 + MEMBER_AVATAR_SIZE + 18
    icon = None
    if personastate == 2:
        icon = Image.open(busy_path)
    elif personastate == 4:
        icon = Image.open(zzz_online_path if status == "在线" else zzz_gaming_path)
    # 让 zzz 图标与名字之间留出更明显的间距
    icon_gap = 12
    icon_space = icon.width + 2 * icon_gap if icon else 0

    # 主名优先、群昵称小字挂尾,超宽均省略号截断,避免画出图片外
    name_drawn, nick_drawn = _fit_name_nick(
        draw, friend_name, nickname or "", name_font, nick_font, 6,
        WIDTH - name_x - 10 - icon_space,
    )

    # 绘制头像
    canvas.paste(avatar_with_border(friend_avatar), (20, 6))

    # 忙碌/打盹沿用"在线"的配色(原实现通过递归 personastate=1 达到同样效果)
    if personastate in (2, 4):
        draw_state = 1
    else:
        draw_state = personastate

    if status != "在线" and draw_state == 1:
        fill = (hex_to_rgb("e3ffc2"), hex_to_rgb("8ebe56"))
    elif status != "离开" and draw_state == 3:
        fill = (hex_to_rgb("e3ffc2"), hex_to_rgb("8ebe56"))
    else:
        fill = personastate_colors[draw_state]

    # 绘制名称:steam 昵称 -> 状态图标 -> 群昵称
    x = name_x
    draw.text((x, 12), name_drawn, font=name_font, fill=fill[0])
    x += int(draw.textlength(name_drawn, font=name_font))
    if icon:
        canvas.paste(icon, (x + icon_gap, 18))
        x += icon_gap + icon.width + icon_gap
    if nick_drawn:
        draw.text((x, 13), nick_drawn, font=nick_font, fill=hex_to_rgb("969696"))

    # 绘制状态
    draw.text(
        (22 + MEMBER_AVATAR_SIZE + 16, 36),
        status,
        font=get_font(font_regular_path, 18),
        fill=fill[1],
    )

    return canvas


def _draw_game_group(members: list[dict]) -> Image.Image:
    """绘制同一款游戏的分组卡片:游戏图标 + 游戏名 + 人数 + 好友列表"""
    header_height = 52
    game_name = members[0].get("game_name") or members[0].get("status") or "游戏中"
    icon = members[0].get("game_icon")

    canvas = Image.new(
        "RGB",
        (WIDTH, header_height + 64 * len(members)),
        hex_to_rgb("1e2024"),
    )
    draw = ImageDraw.Draw(canvas)

    # 游戏图标(Steam header.jpg 是宽图,先居中裁成正方形再缩放)
    x = GAME_ICON_X
    if icon:
        icon_w, icon_h = icon.size
        if icon_w > icon_h:
            left = (icon_w - icon_h) // 2
            icon = icon.crop((left, 0, left + icon_h, icon_h))
        elif icon_h > icon_w:
            top = (icon_h - icon_w) // 2
            icon = icon.crop((0, top, icon_w, top + icon_w))
        icon = icon.resize((GAME_ICON_SIZE, GAME_ICON_SIZE), Image.BICUBIC)
        canvas.paste(icon, (x, (header_height - GAME_ICON_SIZE) // 2))
        x += GAME_ICON_SIZE + 12

    # 游戏名(与玩家信息的水平对齐点一致)
    game_font = get_font(font_bold_path, 16)
    max_game_width = WIDTH - GAME_NAME_X - 100
    if draw.textlength(game_name, font=game_font) > max_game_width:
        game_name = _truncate_with_ellipsis(draw, game_name, game_font, max_game_width)
    draw.text(
        (GAME_NAME_X, header_height // 2 - 10),
        game_name,
        font=game_font,
        fill=hex_to_rgb("8f989b"),
    )

    # 右侧人数
    count_text = f"{len(members)} 人在玩"
    count_font = get_font(font_regular_path, 14)
    draw.text(
        (
            WIDTH - draw.textlength(count_text, font=count_font) - 12,
            header_height // 2 - 9,
        ),
        count_text,
        font=count_font,
        fill=hex_to_rgb("67665c"),
    )

    # 好友行(头像与游戏名水平对齐,形成树结构)
    friend_indent = GAME_NAME_X - 22  # draw_friend_status 内部头像起点为 22
    for i, member in enumerate(members):
        status = member["status"]
        if status in ("在线", "未知", "") and member.get("game_name"):
            status = member["game_name"]
        row = draw_friend_status(
            member["avatar"],
            member["name"],
            status,
            member["personastate"],
            member.get("nickname"),
        )
        canvas.paste(row, (friend_indent, header_height + 64 * i))

    return canvas


def draw_single_game_friend(
    game_icon: Image.Image | None,
    friend_avatar: Image.Image,
    friend_name: str,
    game_name: str,
    status: str,
    personastate: int,
    nickname: str = None,
) -> Image.Image:
    """单人游戏行:游戏图标 + 头像 + 昵称 + 游戏名 + 状态"""
    row_height = 76
    icon_size = GAME_ICON_SIZE
    canvas = Image.new("RGB", (WIDTH, row_height), hex_to_rgb("1e2024"))
    draw = ImageDraw.Draw(canvas)

    # 游戏图标(最左,和多人组头一致)
    if game_icon:
        icon_w, icon_h = game_icon.size
        if icon_w > icon_h:
            left = (icon_w - icon_h) // 2
            game_icon = game_icon.crop((left, 0, left + icon_h, icon_h))
        elif icon_h > icon_w:
            top = (icon_h - icon_w) // 2
            game_icon = game_icon.crop((0, top, icon_w, top + icon_w))
        game_icon = game_icon.resize((icon_size, icon_size), Image.BICUBIC)
        canvas.paste(game_icon, (GAME_ICON_X, (row_height - icon_size) // 2))

    # 头像(与多人玩家信息对齐到 GAME_NAME_X)
    friend_avatar = friend_avatar.resize(
        (MEMBER_AVATAR_SIZE, MEMBER_AVATAR_SIZE), Image.BICUBIC
    )
    canvas.paste(avatar_with_border(friend_avatar), (PLAYER_AVATAR_X, 8))

    # 名称行:steam 昵称 -> 状态图标 -> 群昵称
    name_font = get_font(font_bold_path, 18)
    nick_font = get_font(font_light_path, 13)
    name_x = PLAYER_NAME_X
    icon = None
    if personastate == 2:
        icon = Image.open(busy_path)
    elif personastate == 4:
        icon = Image.open(zzz_online_path if status == "在线" else zzz_gaming_path)
    icon_gap = 12
    icon_space = icon.width + 2 * icon_gap if icon else 0
    name_drawn, nick_drawn = _fit_name_nick(
        draw, friend_name, nickname or "", name_font, nick_font, 6,
        WIDTH - name_x - 10 - icon_space,
    )

    if personastate in (2, 4):
        draw_state = 1
    else:
        draw_state = personastate
    if status != "在线" and draw_state == 1:
        fill = (hex_to_rgb("e3ffc2"), hex_to_rgb("8ebe56"))
    elif status != "离开" and draw_state == 3:
        fill = (hex_to_rgb("e3ffc2"), hex_to_rgb("8ebe56"))
    else:
        fill = personastate_colors[draw_state]

    x = name_x
    draw.text((x, 8), name_drawn, font=name_font, fill=fill[0])
    x += int(draw.textlength(name_drawn, font=name_font))
    if icon:
        canvas.paste(icon, (x + icon_gap, 14))
        x += icon_gap + icon.width + icon_gap
    if nick_drawn:
        draw.text((x, 9), nick_drawn, font=nick_font, fill=hex_to_rgb("969696"))

    # 游戏名
    if game_name:
        draw.text(
            (name_x, 30),
            game_name,
            font=get_font(font_regular_path, 15),
            fill=hex_to_rgb("91c257"),
        )

    # 状态详情(与游戏名相同则不重复画)
    if status and status != game_name:
        draw.text(
            (name_x, 48),
            status,
            font=get_font(font_regular_path, 14),
            fill=hex_to_rgb("969696"),
        )

    return canvas


def draw_gaming_friends_status(data: list[dict]) -> Image.Image:
    # 按游戏分组:同一游戏的人列在同一个游戏标题下
    groups: dict[tuple, list[dict]] = {}
    for d in data:
        key = (d.get("gameid"), d.get("game_name") or d.get("status"))
        groups.setdefault(key, []).append(d)

    # 排序:多人组按人数降序在前,单人组按游戏名 A-Z 在后
    def _group_name(members: list[dict]) -> str:
        return (members[0].get("game_name") or members[0].get("status") or "").lower()

    group_list = list(groups.values())
    multi_groups = [m for m in group_list if len(m) >= 2]
    single_groups = [m for m in group_list if len(m) == 1]
    multi_groups.sort(key=lambda m: (-len(m), _group_name(m)))
    single_groups.sort(key=_group_name)

    parts: list[Image.Image] = []
    for members in multi_groups + single_groups:
        if len(members) == 1:
            # 一个人玩的游戏:游戏图标 + 头像昵称 + 游戏名 + 状态
            member = members[0]
            status = member["status"]
            game_name = member.get("game_name") or ""
            if status in ("在线", "未知", "") and game_name:
                status = game_name
            parts.append(
                draw_single_game_friend(
                    member.get("game_icon"),
                    member["avatar"],
                    member["name"],
                    game_name,
                    status,
                    member["personastate"],
                    member.get("nickname"),
                )
            )
        else:
            parts.append(_draw_game_group(members))

    if not parts:
        return Image.new("RGB", (WIDTH, 64), hex_to_rgb("1e2024"))
    return vertically_concatenate_images(parts)


def draw_online_friends_status(data: List[Dict[str, str]]) -> Image.Image:
    canvas = Image.new(
        "RGB",
        (WIDTH, 64 + (MEMBER_AVATAR_SIZE + 16) * len(data) + 16),
        hex_to_rgb("1e2024"),
    )

    draw = ImageDraw.Draw(canvas)

    # 绘制标题
    draw.text(
        (22, 22),
        "在线好友",
        hex_to_rgb("c5d6d4"),
        font=get_font(font_regular_path, 22),
    )

    # 绘制在线人数
    draw.text(
        (115, 25),
        f"({len(data)})",
        hex_to_rgb("67665c"),
        font=get_font(font_regular_path, 18),
    )

    # 绘制好友头像和名称
    friends_status_list = [
        draw_friend_status(
            d["avatar"], d["name"], d["status"], d["personastate"], d["nickname"]
        )
        for d in data
    ]

    # 拼接好友头像和名称
    for i, friend_status in enumerate(friends_status_list):
        canvas.paste(friend_status, (0, 64 + (MEMBER_AVATAR_SIZE + 16) * i))

    return canvas


def draw_offline_friends_status(data: List[Dict[str, str]]) -> Image.Image:
    canvas = Image.new(
        "RGB",
        (WIDTH, 64 + (MEMBER_AVATAR_SIZE + 16) * len(data) + 16),
        hex_to_rgb("1e2024"),
    )

    draw = ImageDraw.Draw(canvas)

    # 绘制标题
    draw.text(
        (22, 22),
        "离线",
        hex_to_rgb("c5d6d4"),
        font=get_font(font_regular_path, 22),
    )

    # 绘制离线人数
    draw.text(
        (72, 25),
        f"({len(data)})",
        hex_to_rgb("67665c"),
        font=get_font(font_regular_path, 18),
    )

    # 绘制好友头像和名称
    friends_status_list = [
        draw_friend_status(
            d["avatar"], d["name"], d["status"], d["personastate"], d["nickname"]
        )
        for d in data
    ]

    # 拼接好友头像和名称
    for i, friend_status in enumerate(friends_status_list):
        canvas.paste(friend_status, (0, 64 + (MEMBER_AVATAR_SIZE + 16) * i))

    return canvas


def draw_friends_status(
    parent_avatar: Image.Image, parent_name: str, data: List[Dict[str, str]]
):
    data.sort(key=lambda x: x["personastate"])

    def _is_gaming(d: Dict[str, str]) -> bool:
        # 有 gameid 说明确实在游戏里:即使 Steam 没返回详细状态(gameextrainfo),
        # 也归入"游戏中"并显示游戏名,符合"具体状态获取不到就显示游戏名字"。
        if d.get("gameid"):
            return d["personastate"] in (1, 2, 3, 4)
        return (
            (d["personastate"] == 1 and d["status"] != "在线")
            or (d["personastate"] == 3 and d["status"] != "离开")
            or (d["personastate"] == 4 and d["status"] != "在线")
        )

    parent_status = draw_parent_status(parent_avatar, parent_name)
    friends_search = draw_friends_search()

    status_images: List[Image.Image] = []
    height = parent_status.height + friends_search.height

    gaming_data = [d for d in data if _is_gaming(d)]

    if gaming_data:
        status_images.append(draw_gaming_friends_status(gaming_data))
        height += status_images[-1].height

    online_data = [
        d
        for d in data
        if not _is_gaming(d)
        and (
            (d["personastate"] == 1 and d["status"] == "在线")
            or (d["personastate"] == 3 and d["status"] == "离开")
            or (d["personastate"] == 4 and d["status"] == "在线")
            or (d["personastate"] in [2, 5, 6])
        )
    ]
    # 按 1, 2, 4, 5, 6, 3 的顺序排序
    online_data.sort(key=lambda x: (7 if x["personastate"] == 3 else x["personastate"]))

    if online_data:
        status_images.append(draw_online_friends_status(online_data))
        height += status_images[-1].height

    offline_data = [d for d in data if d["personastate"] == 0]
    if offline_data:
        status_images.append(draw_offline_friends_status(offline_data))
        height += status_images[-1].height

    # 拼合图片
    canvas = Image.new("RGB", (WIDTH, height), hex_to_rgb("1e2024"))
    draw = ImageDraw.Draw(canvas)

    canvas.paste(parent_status, (0, 0))
    canvas.paste(friends_search, (0, parent_status.height))

    y = parent_status.height + friends_search.height

    for i, status_image in enumerate(status_images):
        canvas.paste(status_image, (0, y))
        y += status_image.height

        # 绘制分割线
        if i != len(status_images) - 1:
            draw.rectangle([0, y - 1, WIDTH, y], fill=hex_to_rgb("333439"))

    return canvas


def get_average_color(image: Image.Image) -> tuple[int, int, int]:
    """获取图片的平均颜色"""
    image_np = np.array(image)
    average_color = image_np.mean(axis=(0, 1)).astype(int)
    return tuple(average_color)


def split_image(
    image: Image.Image, rows: int, cols: int
) -> tuple[list[Image.Image], int, int]:
    """将图片分割为rows * cols份"""
    width, height = image.size
    piece_width = width // cols
    piece_height = height // rows
    pieces = []

    for r in range(rows):
        for c in range(cols):
            box = (
                c * piece_width,
                r * piece_height,
                (c + 1) * piece_width,
                (r + 1) * piece_height,
            )
            piece = image.crop(box)
            pieces.append(piece)

    return pieces, piece_width, piece_height


def recolor_image(image: Image.Image, rows: int, cols: int) -> Image.Image:
    """分片图片，提取平均颜色后拼接"""
    total_average_color = get_average_color(image)  # 获取整体平均颜色
    pieces, piece_width, piece_height = split_image(image, rows, cols)

    diameter = min(pieces[0].size)  # 以最小边为直径
    radius = diameter // 2
    new_image = Image.new("RGB", image.size, total_average_color)

    for i, piece in enumerate(pieces):
        average_color = get_average_color(piece)  # 获取每片的平均颜色

        # 计算放置的位置
        row, col = divmod(i, cols)
        x = col * piece_width + piece_width // 2
        y = row * piece_height + piece_height // 2

        # 画圆
        circle = Image.new("RGBA", (piece_width, piece_height), (0, 0, 0, 0))
        draw = ImageDraw.Draw(circle)
        draw.ellipse((0, 0, piece_width, piece_height), fill=average_color)

        # 将圆形图片粘贴到新图片上
        new_image.paste(circle, (x - radius, y - radius), circle)

    new_image = new_image.filter(ImageFilter.SMOOTH)
    new_image = new_image.filter(ImageFilter.GaussianBlur(50))

    return new_image


def create_gradient_image(
    size: Tuple[int, int], color1: Tuple[int, int, int], color2: Tuple[int, int, int]
) -> Image.Image:
    """创建渐变图片"""
    # 确保颜色值在 0-255 范围内
    color1 = tuple(max(0, min(255, c)) for c in color1)
    color2 = tuple(max(0, min(255, c)) for c in color2)
    # 创建一个渐变的线性空间
    gradient_array = np.linspace(color1, color2, size[0])

    # 将渐变数组的形状调整为 (height, width, 3)
    gradient_image = np.tile(gradient_array, (size[1], 1, 1)).astype(np.uint8)

    return Image.fromarray(gradient_image, "RGBA")


def create_vertical_gradient_rect(width, height, start_color, end_color):
    """
    创建一个在竖直方向上渐变的矩形图像.

    Args:
        width (int): 矩形的宽度 (以像素为单位).
        height (int): 矩形的高度 (以像素为单位).
        start_color (tuple): 起始颜色，格式为 (R, G, B)，每个值范围为 0-255.
        end_color (tuple): 结束颜色，格式为 (R, G, B)，每个值范围为 0-255.

    Returns:
        Image: PIL Image 对象，表示生成的渐变矩形.
    """
    if width <= 0 or height <= 0:
        return Image.new("RGBA", (1, 1), (0, 0, 0, 0))
    # 确保颜色不超过 0-255 的范围
    start_color = tuple(max(0, min(255, c)) for c in start_color)
    end_color = tuple(max(0, min(255, c)) for c in end_color)

    # 使用 NumPy 创建一个线性渐变数组
    gradient_array = np.linspace(start_color, end_color, num=height, dtype=np.uint8)
    gradient_array = np.tile(gradient_array[:, np.newaxis, :], (1, width, 1))

    # 使用 Pillow 创建图像并填充颜色
    image = Image.fromarray(gradient_array)
    return image


def random_color_offset(
    color: Tuple[int, int, int], offset: int
) -> Tuple[int, int, int]:
    return tuple(
        min(255, max(0, c + np.random.randint(-offset, offset + 1))) for c in color
    )


def get_brightest_and_darkest_color(
    image: Image.Image,
    saturation_threshold: int = 100,
    hue_difference_threshold: int = 30,
) -> Tuple[Tuple[int, int, int], Tuple[int, int, int]]:
    """获取图片最亮和最暗的颜色"""
    # 将RGB图像转换为HSV
    img_hsv = np.array(image.convert("HSV"))

    # 设定一个阈值来定义“鲜艳的颜色”，例如饱和度大于150
    vivid_mask = img_hsv[..., 1] > saturation_threshold

    # 获取饱和度较高（鲜艳）的像素索引
    vivid_pixels = img_hsv[vivid_mask]

    if len(vivid_pixels) < 10:
        return get_brightest_and_darkest_color(image, saturation_threshold - 10)

    # 在鲜艳的像素中，根据亮度（V通道）找到最亮和最暗的颜色
    brightest_pixel = vivid_pixels[np.argmax(vivid_pixels[..., 2])]
    darkest_pixel = vivid_pixels[np.argmin(vivid_pixels[..., 2])]

    # 获取最亮和最暗的颜色的色相差异
    hue_difference = abs(int(brightest_pixel[0]) - int(darkest_pixel[0]))

    # 如果色相差异过小，则尝试寻找新的最暗颜色，直到色相差异大于设定阈值
    if hue_difference < hue_difference_threshold:
        possible_dark_pixels = vivid_pixels[vivid_pixels[..., 0] != brightest_pixel[0]]
        if len(possible_dark_pixels) > 0:
            darkest_pixel = possible_dark_pixels[
                np.argmin(possible_dark_pixels[..., 2])
            ]

    # 将最亮和最暗的像素从HSV转回RGB
    brightest_color = (
        Image.fromarray(np.uint8([[brightest_pixel]]), "HSV")
        .convert("RGB")
        .getpixel((0, 0))
    )
    darkest_color = (
        Image.fromarray(np.uint8([[darkest_pixel]]), "HSV")
        .convert("RGB")
        .getpixel((0, 0))
    )

    return brightest_color, darkest_color


def draw_game_info(
    header: Image.Image,
    game_name: str,
    game_time: str,
    last_play_time: str,
    achievements: List[Achievements],
    completed_achievement_number: int,
    total_achievement_number: int,
    achievement_color: Tuple[int, int, int],
    two_week_time: Optional[str] = None,
) -> Image.Image:
    bg = Image.new("RGBA", (880, 110 + 64 + 10), (0, 0, 0, 110))
    header = header.resize((229, 86), Image.BICUBIC)
    bg.paste(header, (10, 110 // 2 - header.height // 2))

    draw = ImageDraw.Draw(bg)

    # 近两周时长(可选):右上角绿色小字,游戏名超宽时先截断避让
    two_week_width = 0
    if two_week_time:
        font_two_week = get_font(font_light_path, 20)
        two_week_width = int(draw.textlength(two_week_time, font=font_two_week))
        draw.text(
            (bg.width - two_week_width - 10, 22),
            two_week_time,
            font=font_two_week,
            fill=hex_to_rgb("91c257"),
        )

    # 画游戏名
    name_font = get_font(font_regular_path, 26)
    max_name_width = bg.width - 260 - 20 - two_week_width - (30 if two_week_width else 0)
    if draw.textlength(game_name, font=name_font) > max_name_width:
        game_name = _truncate_with_ellipsis(draw, game_name, name_font, max_name_width)
    draw.text(
        (260, 10),
        game_name,
        font=name_font,
        fill=(255, 255, 255),
    )

    # 画最后游玩时间
    font = get_font(font_light_path, 22)
    display_text = last_play_time
    draw.text(
        (int(bg.width - font.getlength(display_text)) - 10, 75),
        display_text,
        font=font,
        fill=(150, 150, 150),
    )

    # 画游戏时间
    font = get_font(font_light_path, 22)
    display_text = f"总时数 {game_time}"
    draw.text(
        (int(bg.width - font.getlength(display_text)) - 10, 50),
        display_text,
        font=font,
        fill=(150, 150, 150),
    )

    if completed_achievement_number is None or total_achievement_number is None:
        return bg.crop((0, 0, bg.width, 110))

    # 画成就  + 64 + 10
    achievement_bg = Image.new("RGBA", (860, 64), achievement_color)
    draw_achievement = ImageDraw.Draw(achievement_bg)

    # 画成就进度
    font = get_font(font_light_path, 18)
    x = 14
    draw_achievement.text(
        (x, 20),
        "成就进度",
        font=font,
        fill=(255, 255, 255, 255),
    )
    x += font.getlength("成就进度") + 10
    draw_achievement.text(
        (int(x), 20),
        f"{completed_achievement_number} / {total_achievement_number}",
        font=font,
        fill=(185, 185, 185),
    )
    x += (
        font.getlength(f"{completed_achievement_number} / {total_achievement_number}")
        + 10
    )
    progress_bar = create_progress_bar(
        completed_achievement_number / total_achievement_number, achievement_color
    )
    achievement_bg.paste(progress_bar, (int(x), 24), progress_bar)

    # 画成就图标
    x = 860 - 48 * 6 - 10 * 6
    for achievement in achievements:
        achievement_image = Image.open(BytesIO(achievement["image"])).resize((48, 48))
        achievement_bg.paste(achievement_image, (x, 8))
        x += 48 + 10

    if completed_achievement_number > 6:
        font = get_font(font_regular_path, 22)
        display_text = f"+{completed_achievement_number - 5}"
        draw_achievement.rectangle((x, 8, x + 48, 56), fill=(34, 34, 34))
        draw_achievement.text(
            (x + 24 - font.getlength(display_text) // 2, 18),
            display_text,
            font=font,
            fill=(255, 255, 255),
        )

    bg.paste(achievement_bg, (10, 110), achievement_bg)
    return bg


# 信息卡尺寸/排版常量(调整版式优先动这里)
CARD_WIDTH = 1200                     # 卡片条宽度,背景按此居中裁切
CARD_MARGIN = 20                      # 左右安全边距
LEFT_W = 880                          # 左栏(游戏动态)宽度
RIGHT_X = CARD_MARGIN + LEFT_W + CARD_MARGIN   # 920:右栏起点
RIGHT_W = CARD_WIDTH - RIGHT_X - CARD_MARGIN   # 260:右栏宽度
AVATAR_SIZE = 160
AVATAR_X = 30                         # 头像框约 1.36×头像,需留出外溢空间
HEADER_TEXT_X = AVATAR_X + AVATAR_SIZE + 30    # 220:头部文字统一左对齐点
GAME_GAP = 16                         # 游戏卡片间距
COUNT_ROW_MAX_STEP = 44               # 右栏计数条目间距上限(面板矮时自动收紧)
AVATAR_FRAME_SCALE = 1.36             # 头像框相对头像的缩放(对齐 Steam 内孔比例)

# 状态行配色,key 为 ProfileCardExtra.status_kind
status_row_colors = {
    "in-game": hex_to_rgb("91c257"),
    "online": hex_to_rgb("6dcef5"),
    "away": hex_to_rgb("e0a948"),
    "offline": hex_to_rgb("969697"),
    "private": hex_to_rgb("969697"),
}

# 风控标记配色,key 为 ProfileCardExtra.ban_kind
ban_tag_colors = {
    "vac": hex_to_rgb("c4453c"),
    "trade": hex_to_rgb("c98a2e"),
    "limited": hex_to_rgb("67665c"),
}

# 右栏状态区标题,key 为 ProfileCardExtra.status_kind
status_titles = {
    "in-game": "当前正在游戏",
    "online": "当前在线",
    "away": "当前在线",
    "offline": "当前离线",
    "private": "当前状态",
}


def _draw_kv_parts(
    draw: ImageDraw.ImageDraw,
    x: int,
    y: int,
    parts: List[Tuple[str, tuple]],
    font,
) -> int:
    """按 (文本, 颜色) 依次绘制,返回右边缘 x(间距由文本自带的空格控制)"""
    for text, color in parts:
        draw.text((x, y), text, font=font, fill=color)
        x += int(draw.textlength(text, font=font))
    return x


def _draw_status_row(
    draw: ImageDraw.ImageDraw,
    x: int,
    y: int,
    text: str,
    kind: str = "online",
    second_line: str = "",
) -> None:
    """状态行:彩色圆点 + 文案(游戏中/在线/离线/资料私密),过长可折第二行"""
    color = status_row_colors.get(kind, status_row_colors["online"])
    font = get_font(font_regular_path, 17)
    draw.ellipse((x, y + 4, x + 11, y + 15), fill=color)
    draw.text((x + 19, y), text, font=font, fill=color)
    if second_line:
        draw.text((x + 19, y + 22), second_line, font=font, fill=color)


def _split_two_lines(
    draw: ImageDraw.ImageDraw, text: str, font, max_width: int
) -> List[str]:
    """超宽文本折成最多两行:优先在最后一个放得下的分隔符处断,否则省略号截断"""
    if draw.textlength(text, font=font) <= max_width:
        return [text]
    break_at = None
    for idx, char in enumerate(text):
        if char in ":：" or char == " ":
            if draw.textlength(text[: idx + 1], font=font) <= max_width:
                break_at = idx + 1
    if break_at is None:
        return [_truncate_with_ellipsis(draw, text, font, max_width)]
    second = text[break_at:].strip()
    if draw.textlength(second, font=font) > max_width:
        second = _truncate_with_ellipsis(draw, second, font, max_width)
    return [text[:break_at].strip(), second]


def _draw_level_badge(
    draw: ImageDraw.ImageDraw, x: int, center_y: int, level: int
) -> int:
    """Steam 风格等级圆牌,返回右边缘 x"""
    diameter = 34
    top = center_y - diameter // 2
    draw.ellipse(
        (x, top, x + diameter, top + diameter),
        fill=hex_to_rgb("1b2838"),
        outline=hex_to_rgb("66c0f4"),
        width=2,
    )
    font = get_font(font_bold_path, 18)
    text = str(level)
    text_width = draw.textlength(text, font=font)
    draw.text(
        (x + (diameter - text_width) / 2, top + (diameter - font.size) / 2 - 3),
        text,
        font=font,
        fill=(255, 255, 255),
    )
    return x + diameter


def _draw_ban_tag(
    draw: ImageDraw.ImageDraw, x: int, y: int, text: str, kind: str
) -> int:
    """风控标记圆角标签,返回右边缘 x"""
    font = get_font(font_regular_path, 13)
    padding_x, padding_y = 9, 4
    width = draw.textlength(text, font=font) + padding_x * 2
    height = font.size + padding_y * 2
    draw.rounded_rectangle(
        (x, y, x + width, y + height),
        radius=height // 2,
        fill=ban_tag_colors.get(kind, ban_tag_colors["limited"]),
    )
    draw.text(
        (x + padding_x, y + padding_y - 1),
        text,
        font=font,
        fill=(255, 255, 255),
    )
    return int(x + width)


def draw_player_status(
    player_bg: Image.Image,
    player_avatar: Image.Image,
    player_name: str,
    player_id: str,
    player_description: str,
    player_last_two_weeks_time: str,  # e.g. 10.2 小时(过去 2 周)
    player_games: List[DrawPlayerStatusData],
    extra: Optional[ProfileCardExtra] = None,
    avatar_frame: Optional[bytes] = None,
):
    """信息卡:通栏头部 + 左栏「游戏动态」+ 右栏「当前在线/计数」(参考 Steam 官方资料页)"""
    if isinstance(player_bg, bytes):
        player_bg = Image.open(BytesIO(player_bg))
    if isinstance(player_avatar, bytes):
        player_avatar = Image.open(BytesIO(player_avatar))
    extra = extra or {}

    bg = recolor_image(
        player_bg.crop(
            (
                (player_bg.width - CARD_WIDTH) // 2,
                0,
                (player_bg.width + CARD_WIDTH) // 2,
                player_bg.height,
            )
        ),
        10,
        10,
    )
    bg = ImageEnhance.Brightness(bg).enhance(0.7)
    draw = ImageDraw.Draw(bg)

    # ---------- 头部:头像(+头像框)/ 昵称+等级+风控 / 简介 / 好友代码·注册时间 ----------
    avatar = player_avatar.convert("RGB").resize(
        (AVATAR_SIZE, AVATAR_SIZE), Image.BICUBIC
    )
    bg.paste(avatar_with_border(avatar), (AVATAR_X - 2, AVATAR_X - 2))
    if avatar_frame:
        try:
            frame = Image.open(BytesIO(avatar_frame)).convert("RGBA")
            frame_size = int(AVATAR_SIZE * AVATAR_FRAME_SCALE)
            frame = frame.resize((frame_size, frame_size), Image.LANCZOS)
            frame_pos = AVATAR_X + (AVATAR_SIZE - frame_size) // 2
            bg.paste(frame, (frame_pos, frame_pos), frame)
        except Exception:
            pass  # 头像框只是装饰,画不出来不影响整卡

    # 好友代码/注册时间的标签色:比正文灰稍亮一档(#969696 在深色底上偏暗)
    text_gray = hex_to_rgb("b4b4b4")
    name_font = get_font(font_light_path, 38)
    reserved = 34 + 10 if extra.get("level") is not None else 0
    if extra.get("ban_text"):
        ban_font = get_font(font_regular_path, 13)
        reserved += int(draw.textlength(extra["ban_text"], font=ban_font)) + 18 + 10
    max_name_width = CARD_WIDTH - CARD_MARGIN - HEADER_TEXT_X - reserved
    if draw.textlength(player_name, font=name_font) > max_name_width:
        player_name = _truncate_with_ellipsis(
            draw, player_name, name_font, max_name_width
        )
    name_y = AVATAR_X + 6
    draw.text(
        (HEADER_TEXT_X, name_y), player_name, font=name_font, fill=(255, 255, 255)
    )

    # 等级圆牌 / 风控标记紧随昵称
    cursor = HEADER_TEXT_X + int(draw.textlength(player_name, font=name_font)) + 12
    if extra.get("level") is not None:
        cursor = _draw_level_badge(draw, cursor, name_y + 21, extra["level"]) + 10
    if extra.get("ban_text"):
        _draw_ban_tag(
            draw, cursor, name_y + 10, extra["ban_text"], extra.get("ban_kind") or "limited"
        )

    # 简介(最多 3 行)
    desc_font = get_font(font_light_path, 20)
    desc_top = name_y + 60
    max_desc_width = CARD_WIDTH - CARD_MARGIN - HEADER_TEXT_X
    line_width = 0
    offset = 0
    line = ""
    for idx, char in enumerate(player_description):
        line += char
        line_width += desc_font.getlength(char)
        if (
            line_width > max_desc_width
            or idx == len(player_description) - 1
            or char == "\n"
        ):
            draw.text(
                (HEADER_TEXT_X, desc_top + offset),
                line,
                font=desc_font,
                fill=(235, 235, 235),
            )
            line = ""
            line_width = 0
            offset += 27
        if offset >= 27 * 3:
            break

    # 好友代码 / 注册时间
    meta_font = get_font(font_regular_path, 16)
    meta_y = desc_top + offset + 14
    meta_parts = [("好友代码: ", text_gray), (player_id, (255, 255, 255))]
    if extra.get("member_since"):
        meta_parts += [
            ("      注册时间: ", text_gray),
            (extra["member_since"], (255, 255, 255)),
        ]
    _draw_kv_parts(draw, HEADER_TEXT_X, meta_y, meta_parts, meta_font)

    header_h = max(AVATAR_X + AVATAR_SIZE + 26, meta_y + 22) + 14
    draw.rectangle(
        (CARD_MARGIN, header_h - 1, CARD_WIDTH - CARD_MARGIN, header_h),
        fill=hex_to_rgb("333439"),
    )

    # ---------- 左栏:游戏动态 ----------
    body_top = header_h + 16
    brightest_color, darkest_color = get_brightest_and_darkest_color(player_bg)
    brightest_color = tuple(map(lambda x: x - 30 if x >= 30 else 0, brightest_color))
    darkest_color = tuple(
        map(lambda x: x + 30 if x <= 255 - 30 else 255, darkest_color)
    )
    # 成就条底色:取背景亮色的深色变体(压暗一些,保证白色文字和数字读得清)
    hsv_achievement_color = rgb_to_hsv(*brightest_color)
    achievement_color = tuple(
        map(
            int,
            hsv_to_rgb(
                hsv_achievement_color[0],
                hsv_achievement_color[1] * 0.8,
                hsv_achievement_color[2] * 0.35,
            ),
        )
    )

    cards: List[Image.Image] = []
    for game in player_games:
        cards.append(
            draw_game_info(
                Image.open(BytesIO(game["game_header"])),
                game["game_name"],
                game["game_time"],
                game["last_play_time"],
                game["achievements"],
                game["completed_achievement_number"],
                game["total_achievement_number"],
                achievement_color,
                two_week_time=game.get("two_week_time"),
            )
        )

    # 背景太矮时先向下补一段(拉伸底部横条),避免内容整体被裁
    min_height = body_top + 58 + 110 + CARD_MARGIN
    if bg.height < min_height:
        strip = bg.crop((0, bg.height - 8, CARD_WIDTH, bg.height)).resize(
            (CARD_WIDTH, min_height - bg.height), Image.BICUBIC
        )
        canvas = Image.new("RGB", (CARD_WIDTH, min_height))
        canvas.paste(bg, (0, 0))
        canvas.paste(strip, (0, bg.height))
        bg = canvas
        draw = ImageDraw.Draw(bg)

    # 按可用高度筛出画得下的游戏卡片(至少画第一条)
    y = body_top + 58
    max_bottom = bg.height - CARD_MARGIN
    shown_cards: List[Image.Image] = []
    for card in cards:
        if shown_cards and y + card.height > max_bottom:
            break
        shown_cards.append(card)
        y += card.height + GAME_GAP
    left_bottom = (y - GAME_GAP + 12) if shown_cards else (body_top + 66)

    # 左右两栏等高的半透明底板
    left_panel = Image.new("RGBA", (LEFT_W, left_bottom - body_top), (0, 0, 0, 120))
    bg.paste(left_panel, (CARD_MARGIN, body_top), left_panel)
    right_panel = Image.new("RGBA", (RIGHT_W, left_bottom - body_top), (0, 0, 0, 120))
    bg.paste(right_panel, (RIGHT_X, body_top), right_panel)

    # 左栏标题条(渐变)+ 近两周总时长
    gradient = create_gradient_image(
        (LEFT_W, 50),
        (brightest_color[0], brightest_color[1], brightest_color[2], 128),
        (darkest_color[0], darkest_color[1], darkest_color[2], 128),
    )
    bg.paste(gradient, (CARD_MARGIN, body_top), gradient)
    draw.text(
        (CARD_MARGIN + 14, body_top + 7),
        "游戏动态",
        font=get_font(font_light_path, 26),
        fill=(255, 255, 255),
    )
    if player_last_two_weeks_time:
        total_font = get_font(font_light_path, 22)
        total_width = total_font.getlength(player_last_two_weeks_time)
        draw.text(
            (CARD_MARGIN + LEFT_W - total_width - 14, body_top + 9),
            player_last_two_weeks_time,
            font=total_font,
            fill=(255, 255, 255),
        )
    y = body_top + 58
    for card in shown_cards:
        bg.paste(card, (CARD_MARGIN, y), card.convert("RGBA"))
        y += card.height + GAME_GAP

    # ---------- 右栏:当前在线 + 计数 ----------
    status_title = status_titles.get(
        extra.get("status_kind") or "online", "当前在线"
    )
    draw.text(
        (RIGHT_X + 20, body_top + 14),
        status_title,
        font=get_font(font_light_path, 20),
        fill=hex_to_rgb("c5d6d4"),
    )
    status_extra_h = 0
    if extra.get("status_text"):
        status_font = get_font(font_regular_path, 17)
        status_lines = _split_two_lines(
            draw, extra["status_text"], status_font, RIGHT_W - 60
        )
        status_extra_h = 22 * (len(status_lines) - 1)
        _draw_status_row(
            draw,
            RIGHT_X + 20,
            body_top + 46,
            status_lines[0],
            extra.get("status_kind") or "online",
            status_lines[1] if len(status_lines) > 1 else "",
        )
    divider_y = body_top + 76 + status_extra_h
    draw.rectangle(
        (RIGHT_X + 20, divider_y, RIGHT_X + RIGHT_W - 20, divider_y + 1),
        fill=hex_to_rgb("333439"),
    )

    count_rows = list((extra.get("counts") or {}).items())
    panel_h = left_bottom - body_top - status_extra_h
    step = COUNT_ROW_MAX_STEP
    if count_rows:
        step = min(COUNT_ROW_MAX_STEP, max(26, (panel_h - 114) // len(count_rows)))
    row_font = get_font(font_regular_path, 15)
    ry = divider_y + 14
    for label, value in count_rows:
        if ry + 20 > left_bottom - 12:  # 面板放不下就不画,保证不越界
            break
        draw.text((RIGHT_X + 20, ry), label, font=row_font, fill=hex_to_rgb("8f989b"))
        value_text = str(value)
        draw.text(
            (RIGHT_X + RIGHT_W - 20 - row_font.getlength(value_text), ry),
            value_text,
            font=row_font,
            fill=(255, 255, 255),
        )
        ry += step

    # 内容高于背景时(极端情况),背景向下拉伸补足后再贴回
    if bg.height > player_bg.height:
        strip = player_bg.crop(
            (0, player_bg.height - 8, player_bg.width, player_bg.height)
        ).resize((player_bg.width, bg.height - player_bg.height), Image.BICUBIC)
        canvas = Image.new("RGB", (player_bg.width, bg.height))
        canvas.paste(player_bg, (0, 0))
        canvas.paste(strip, (0, player_bg.height))
        player_bg = canvas

    player_bg.paste(bg, ((player_bg.width - CARD_WIDTH) // 2, 0), bg.convert("RGBA"))
    return player_bg


def rounded_rectangle(
    image: Image.Image,
    radius: int,
    border=False,
    border_width=0,
    border_color=(0, 0, 0),
):
    """
    将给定的Image.Image对象切割为圆角矩形。

    Args:
        image: 一个PIL Image对象。
        radius: 圆角半径，单位为像素。
        border: 是否需要边框，默认为False。
        border_width: 边框宽度，单位为像素，默认为0。
        border_color: 边框颜色，RGB元组，默认为黑色(0, 0, 0)。

    Returns:
        一个PIL Image对象，表示切割后的圆角矩形图像。
    """

    width, height = image.size

    image_ = Image.new("RGBA", (width + 1, height + 1), (0, 0, 0, 0))
    image_.paste(image, (0, 0), image.convert("RGBA"))

    # 创建一个圆角矩形的遮罩
    result = Image.new("RGBA", (width + 1, height + 1), (0, 0, 0, 0))
    mask = Image.new("L", (width + 1, height + 1), 0)
    draw = ImageDraw.Draw(mask)
    image_draw = ImageDraw.Draw(result)

    # 绘制圆角矩形
    draw.rounded_rectangle((0, 0, width, height), radius=radius, fill=255)

    # 应用遮罩到原始图像
    result.paste(image_, (0, 0), mask)

    # 添加边框 (如果需要)
    if border:
        image_draw.rounded_rectangle(
            (0, 0, width, height),
            radius=radius,
            outline=border_color,
            width=border_width,
        )

    return result


def create_progress_bar(
    progress: float, color: Tuple[int, int, int], width=186, height=16
):
    color_hsv = rgb_to_hsv(*color)

    # 外条
    bar_color = tuple(
        map(int, hsv_to_rgb(color_hsv[0], color_hsv[1], color_hsv[2] * 0.8))
    )
    border_color = tuple(map(lambda x: max(x - 20, 0), color))
    border_image = rounded_rectangle(
        Image.new("RGBA", (width, height), bar_color),
        8,
        border=True,
        border_width=1,
        border_color=border_color,
    )

    # 内条
    bar_color_top = tuple(
        map(int, hsv_to_rgb(color_hsv[0], color_hsv[1] / 2, color_hsv[2] * 5 / 2))
    )
    bar_color_bottem = tuple(
        map(int, hsv_to_rgb(color_hsv[0], color_hsv[1] / 2, color_hsv[2]))
    )

    bar_image = create_vertical_gradient_rect(
        int(width * progress) - 6, height - 4, bar_color_top, bar_color_bottem
    )
    bar_image = rounded_rectangle(bar_image, 6)

    # 合并
    border_image.paste(bar_image, (3, 2), bar_image)

    return border_image