from collections import defaultdict
from datetime import datetime, timedelta
from typing import Any, Dict, Tuple, List

from src.common.logger import get_module_logger
from src.manager.async_task_manager import AsyncTask

from ...common.database import db
from src.manager.local_store_manager import local_storage

logger = get_module_logger("maibot_statistic")

# 统计数据的键
TOTAL_REQ_CNT = "total_requests"
TOTAL_COST = "total_cost"
REQ_CNT_BY_TYPE = "requests_by_type"
REQ_CNT_BY_USER = "requests_by_user"
REQ_CNT_BY_MODEL = "requests_by_model"
IN_TOK_BY_TYPE = "in_tokens_by_type"
IN_TOK_BY_USER = "in_tokens_by_user"
IN_TOK_BY_MODEL = "in_tokens_by_model"
OUT_TOK_BY_TYPE = "out_tokens_by_type"
OUT_TOK_BY_USER = "out_tokens_by_user"
OUT_TOK_BY_MODEL = "out_tokens_by_model"
TOTAL_TOK_BY_TYPE = "tokens_by_type"
TOTAL_TOK_BY_USER = "tokens_by_user"
TOTAL_TOK_BY_MODEL = "tokens_by_model"
COST_BY_TYPE = "costs_by_type"
COST_BY_USER = "costs_by_user"
COST_BY_MODEL = "costs_by_model"
ONLINE_TIME = "online_time"
TOTAL_MSG_CNT = "total_messages"
MSG_CNT_BY_CHAT = "messages_by_chat"


class OnlineTimeRecordTask(AsyncTask):
    """在线时间记录任务"""

    def __init__(self):
        super().__init__(task_name="Online Time Record Task", run_interval=60)

        self.record_id: str | None = None
        """记录ID"""

        self._init_database()  # 初始化数据库

    @staticmethod
    def _init_database():
        """初始化数据库"""
        if "online_time" not in db.list_collection_names():
            # 初始化数据库（在线时长）
            db.create_collection("online_time")
            # 创建索引
            if ("end_timestamp", 1) not in db.online_time.list_indexes():
                db.online_time.create_index([("end_timestamp", 1)])

    async def run(self):
        try:
            if self.record_id:
                # 如果有记录，则更新结束时间
                db.online_time.update_one(
                    {"_id": self.record_id},
                    {
                        "$set": {
                            "end_timestamp": datetime.now() + timedelta(minutes=1),
                        }
                    },
                )
            else:
                # 如果没有记录，检查一分钟以内是否已有记录
                current_time = datetime.now()
                recent_record = db.online_time.find_one(
                    {"end_timestamp": {"$gte": current_time - timedelta(minutes=1)}}
                )

                if not recent_record:
                    # 若没有记录，则插入新的在线时间记录
                    self.record_id = db.online_time.insert_one(
                        {
                            "start_timestamp": current_time,
                            "end_timestamp": current_time + timedelta(minutes=1),
                        }
                    ).inserted_id
                else:
                    # 如果有记录，则更新结束时间
                    self.record_id = recent_record["_id"]
                    db.online_time.update_one(
                        {"_id": self.record_id},
                        {
                            "$set": {
                                "end_timestamp": current_time + timedelta(minutes=1),
                            }
                        },
                    )
        except Exception:
            logger.exception("在线时间记录失败")


def _format_online_time(online_seconds: int) -> str:
    """
    格式化在线时间
    :param online_seconds: 在线时间（秒）
    :return: 格式化后的在线时间字符串
    """
    total_oneline_time = timedelta(seconds=online_seconds)

    days = total_oneline_time.days
    hours = total_oneline_time.seconds // 3600
    minutes = (total_oneline_time.seconds // 60) % 60
    seconds = total_oneline_time.seconds % 60
    if days > 0:
        # 如果在线时间超过1天，则格式化为“X天X小时X分钟”
        total_oneline_time_str = f"{total_oneline_time.days}天{hours}小时{minutes}分钟{seconds}秒"
    elif hours > 0:
        # 如果在线时间超过1小时，则格式化为“X小时X分钟X秒”
        total_oneline_time_str = f"{hours}小时{minutes}分钟{seconds}秒"
    else:
        # 其他情况格式化为“X分钟X秒”
        total_oneline_time_str = f"{minutes}分钟{seconds}秒"

    return total_oneline_time_str


class StatisticOutputTask(AsyncTask):
    """统计输出任务"""

    SEP_LINE = "-" * 84

    def __init__(self, record_file_path: str = "maibot_statistics.html"):
        # 延迟300秒启动，运行间隔300秒
        super().__init__(task_name="Statistics Data Output Task", wait_before_start=0, run_interval=300)

        self.name_mapping: Dict[str, Tuple[str, float]] = {}
        """
            联系人/群聊名称映射 {聊天ID: (联系人/群聊名称, 记录时间（timestamp）)}
            注：设计记录时间的目的是方便更新名称，使联系人/群聊名称保持最新
        """

        self.record_file_path: str = record_file_path
        """
        记录文件路径
        """

        now = datetime.now()
        if "deploy_time" in local_storage:
            # 如果存在部署时间，则使用该时间作为全量统计的起始时间
            deploy_time = datetime.fromtimestamp(local_storage["deploy_time"])
        else:
            # 否则，使用最大时间范围，并记录部署时间为当前时间
            deploy_time = datetime(2000, 1, 1)
            local_storage["deploy_time"] = now.timestamp()

        self.stat_period: List[Tuple[str, timedelta, str]] = [
            ("all_time", now - deploy_time, "自部署以来"),  # 必须保留“all_time”
            ("last_7_days", timedelta(days=7), "最近7天"),
            ("last_24_hours", timedelta(days=1), "最近24小时"),
            ("last_hour", timedelta(hours=1), "最近1小时"),
        ]
        """
        统计时间段 [(统计名称, 统计时间段, 统计描述), ...]
        """

    def _statistic_console_output(self, stats: Dict[str, Any], now: datetime):
        """
        输出统计数据到控制台
        :param stats: 统计数据
        :param now: 基准当前时间
        """
        # 输出最近一小时的统计数据

        output = [
            self.SEP_LINE,
            f"  最近1小时的统计数据  (自{now.strftime('%Y-%m-%d %H:%M:%S')}开始，详细信息见文件：{self.record_file_path})",
            self.SEP_LINE,
            self._format_total_stat(stats["last_hour"]),
            "",
            self._format_model_classified_stat(stats["last_hour"]),
            "",
            self._format_chat_stat(stats["last_hour"]),
            self.SEP_LINE,
            "",
        ]

        logger.info("\n" + "\n".join(output))

    async def run(self):
        try:
            now = datetime.now()
            # 收集统计数据
            stats = self._collect_all_statistics(now)

            # 输出统计数据到控制台
            self._statistic_console_output(stats, now)
            # 输出统计数据到html文件
            self._generate_html_report(stats, now)
        except Exception as e:
            logger.exception(f"输出统计数据过程中发生异常，错误信息：{e}")

    # -- 以下为统计数据收集方法 --

    @staticmethod
    def _collect_model_request_for_period(collect_period: List[Tuple[str, datetime]]) -> Dict[str, Any]:
        """
        收集指定时间段的LLM请求统计数据

        :param collect_period: 统计时间段
        """
        if len(collect_period) <= 0:
            return {}
        else:
            # 排序-按照时间段开始时间降序排列（最晚的时间段在前）
            collect_period.sort(key=lambda x: x[1], reverse=True)

        stats = {
            period_key: {
                # 总LLM请求数
                TOTAL_REQ_CNT: 0,
                # 请求次数统计
                REQ_CNT_BY_TYPE: defaultdict(int),
                REQ_CNT_BY_USER: defaultdict(int),
                REQ_CNT_BY_MODEL: defaultdict(int),
                # 输入Token数
                IN_TOK_BY_TYPE: defaultdict(int),
                IN_TOK_BY_USER: defaultdict(int),
                IN_TOK_BY_MODEL: defaultdict(int),
                # 输出Token数
                OUT_TOK_BY_TYPE: defaultdict(int),
                OUT_TOK_BY_USER: defaultdict(int),
                OUT_TOK_BY_MODEL: defaultdict(int),
                # 总Token数
                TOTAL_TOK_BY_TYPE: defaultdict(int),
                TOTAL_TOK_BY_USER: defaultdict(int),
                TOTAL_TOK_BY_MODEL: defaultdict(int),
                # 总开销
                TOTAL_COST: 0.0,
                # 请求开销统计
                COST_BY_TYPE: defaultdict(float),
                COST_BY_USER: defaultdict(float),
                COST_BY_MODEL: defaultdict(float),
            }
            for period_key, _ in collect_period
        }

        # 以最早的时间戳为起始时间获取记录
        for record in db.llm_usage.find({"timestamp": {"$gte": collect_period[-1][1]}}):
            record_timestamp = record.get("timestamp")
            for idx, (_, period_start) in enumerate(collect_period):
                if record_timestamp >= period_start:
                    # 如果记录时间在当前时间段内，则它一定在更早的时间段内
                    # 因此，我们可以直接跳过更早的时间段的判断，直接更新当前以及更早时间段的统计数据
                    for period_key, _ in collect_period[idx:]:
                        stats[period_key][TOTAL_REQ_CNT] += 1

                        request_type = record.get("request_type", "unknown")  # 请求类型
                        user_id = str(record.get("user_id", "unknown"))  # 用户ID
                        model_name = record.get("model_name", "unknown")  # 模型名称

                        stats[period_key][REQ_CNT_BY_TYPE][request_type] += 1
                        stats[period_key][REQ_CNT_BY_USER][user_id] += 1
                        stats[period_key][REQ_CNT_BY_MODEL][model_name] += 1

                        prompt_tokens = record.get("prompt_tokens", 0)  # 输入Token数
                        completion_tokens = record.get("completion_tokens", 0)  # 输出Token数
                        total_tokens = prompt_tokens + completion_tokens  # Token总数 = 输入Token数 + 输出Token数

                        stats[period_key][IN_TOK_BY_TYPE][request_type] += prompt_tokens
                        stats[period_key][IN_TOK_BY_USER][user_id] += prompt_tokens
                        stats[period_key][IN_TOK_BY_MODEL][model_name] += prompt_tokens

                        stats[period_key][OUT_TOK_BY_TYPE][request_type] += completion_tokens
                        stats[period_key][OUT_TOK_BY_USER][user_id] += completion_tokens
                        stats[period_key][OUT_TOK_BY_MODEL][model_name] += completion_tokens

                        stats[period_key][TOTAL_TOK_BY_TYPE][request_type] += total_tokens
                        stats[period_key][TOTAL_TOK_BY_USER][user_id] += total_tokens
                        stats[period_key][TOTAL_TOK_BY_MODEL][model_name] += total_tokens

                        cost = record.get("cost", 0.0)
                        stats[period_key][TOTAL_COST] += cost
                        stats[period_key][COST_BY_TYPE][request_type] += cost
                        stats[period_key][COST_BY_USER][user_id] += cost
                        stats[period_key][COST_BY_MODEL][model_name] += cost
                    break  # 取消更早时间段的判断

        return stats

    @staticmethod
    def _collect_online_time_for_period(collect_period: List[Tuple[str, datetime]], now: datetime) -> Dict[str, Any]:
        """
        收集指定时间段的在线时间统计数据

        :param collect_period: 统计时间段
        """
        if len(collect_period) <= 0:
            return {}
        else:
            # 排序-按照时间段开始时间降序排列（最晚的时间段在前）
            collect_period.sort(key=lambda x: x[1], reverse=True)

        stats = {
            period_key: {
                # 在线时间统计
                ONLINE_TIME: 0.0,
            }
            for period_key, _ in collect_period
        }

        # 统计在线时间
        for record in db.online_time.find({"end_timestamp": {"$gte": collect_period[-1][1]}}):
            end_timestamp: datetime = record.get("end_timestamp")
            for idx, (_, period_start) in enumerate(collect_period):
                if end_timestamp >= period_start:
                    # 由于end_timestamp会超前标记时间，所以我们需要判断是否晚于当前时间，如果是，则使用当前时间作为结束时间
                    if end_timestamp > now:
                        end_timestamp = now
                    # 如果记录时间在当前时间段内，则它一定在更早的时间段内
                    # 因此，我们可以直接跳过更早的时间段的判断，直接更新当前以及更早时间段的统计数据
                    for period_key, _period_start in collect_period[idx:]:
                        start_timestamp: datetime = record.get("start_timestamp")
                        if start_timestamp < _period_start:
                            # 如果开始时间在查询边界之前，则使用开始时间
                            stats[period_key][ONLINE_TIME] += (end_timestamp - _period_start).total_seconds()
                        else:
                            # 否则，使用开始时间
                            stats[period_key][ONLINE_TIME] += (end_timestamp - start_timestamp).total_seconds()
                    break  # 取消更早时间段的判断

        return stats

    def _collect_message_count_for_period(self, collect_period: List[Tuple[str, datetime]]) -> Dict[str, Any]:
        """
        收集指定时间段的消息统计数据

        :param collect_period: 统计时间段
        """
        if len(collect_period) <= 0:
            return {}
        else:
            # 排序-按照时间段开始时间降序排列（最晚的时间段在前）
            collect_period.sort(key=lambda x: x[1], reverse=True)

        stats = {
            period_key: {
                # 消息统计
                TOTAL_MSG_CNT: 0,
                MSG_CNT_BY_CHAT: defaultdict(int),
            }
            for period_key, _ in collect_period
        }

        # 统计消息量
        for message in db.messages.find({"time": {"$gte": collect_period[-1][1].timestamp()}}):
            chat_info = message.get("chat_info", None)  # 聊天信息
            user_info = message.get("user_info", None)  # 用户信息（消息发送人）
            message_time = message.get("time", 0)  # 消息时间

            group_info = chat_info.get("group_info") if chat_info else None  # 尝试获取群聊信息
            if group_info is not None:
                # 若有群聊信息
                chat_id = f"g{group_info.get('group_id')}"
                chat_name = group_info.get("group_name", f"群{group_info.get('group_id')}")
            elif user_info:
                # 若没有群聊信息，则尝试获取用户信息
                chat_id = f"u{user_info['user_id']}"
                chat_name = user_info["user_nickname"]
            else:
                continue  # 如果没有群组信息也没有用户信息，则跳过

            if chat_id in self.name_mapping:
                if chat_name != self.name_mapping[chat_id][0] and message_time > self.name_mapping[chat_id][1]:
                    # 如果用户名称不同，且新消息时间晚于之前记录的时间，则更新用户名称
                    self.name_mapping[chat_id] = (chat_name, message_time)
            else:
                self.name_mapping[chat_id] = (chat_name, message_time)

            for idx, (_, period_start) in enumerate(collect_period):
                if message_time >= period_start.timestamp():
                    # 如果记录时间在当前时间段内，则它一定在更早的时间段内
                    # 因此，我们可以直接跳过更早的时间段的判断，直接更新当前以及更早时间段的统计数据
                    for period_key, _ in collect_period[idx:]:
                        stats[period_key][TOTAL_MSG_CNT] += 1
                        stats[period_key][MSG_CNT_BY_CHAT][chat_id] += 1
                    break

        return stats

    def _collect_all_statistics(self, now: datetime) -> Dict[str, Dict[str, Any]]:
        """
        收集各时间段的统计数据
        :param now: 基准当前时间
        """

        last_all_time_stat = None

        if "last_full_statistics_timestamp" in local_storage and "last_full_statistics" in local_storage:
            # 若存有上次完整统计的时间戳，则使用该时间戳作为"所有时间"的起始时间，进行增量统计
            last_full_stat_ts: float = local_storage["last_full_statistics_timestamp"]
            last_all_time_stat = local_storage["last_full_statistics"]
            self.stat_period = [item for item in self.stat_period if item[0] != "all_time"]  # 删除"所有时间"的统计时段
            self.stat_period.append(("all_time", now - datetime.fromtimestamp(last_full_stat_ts), "自部署以来的"))

        stat_start_timestamp = [(period[0], now - period[1]) for period in self.stat_period]

        stat = {item[0]: {} for item in self.stat_period}

        model_req_stat = self._collect_model_request_for_period(stat_start_timestamp)
        online_time_stat = self._collect_online_time_for_period(stat_start_timestamp, now)
        message_count_stat = self._collect_message_count_for_period(stat_start_timestamp)

        # 统计数据合并
        # 合并三类统计数据
        for period_key, _ in stat_start_timestamp:
            stat[period_key].update(model_req_stat[period_key])
            stat[period_key].update(online_time_stat[period_key])
            stat[period_key].update(message_count_stat[period_key])

        if last_all_time_stat:
            # 若存在上次完整统计数据，则将其与当前统计数据合并
            for key, val in last_all_time_stat.items():
                if isinstance(val, dict):
                    # 是字典类型，则进行合并
                    for sub_key, sub_val in val.items():
                        stat["all_time"][key][sub_key] += sub_val
                else:
                    # 直接合并
                    stat["all_time"][key] += val

        # 更新上次完整统计数据的时间戳
        local_storage["last_full_statistics_timestamp"] = now.timestamp()
        # 更新上次完整统计数据
        local_storage["last_full_statistics"] = stat["all_time"]

        return stat

    # -- 以下为统计数据格式化方法 --

    @staticmethod
    def _format_total_stat(stats: Dict[str, Any]) -> str:
        """
        格式化总统计数据
        """

        output = [
            f"总在线时间: {_format_online_time(stats[ONLINE_TIME])}",
            f"总消息数: {stats[TOTAL_MSG_CNT]}",
            f"总请求数: {stats[TOTAL_REQ_CNT]}",
            f"总花费: {stats[TOTAL_COST]:.4f}¥",
            "",
        ]

        return "\n".join(output)

    @staticmethod
    def _format_model_classified_stat(stats: Dict[str, Any]) -> str:
        """
        格式化按模型分类的统计数据
        """
        if stats[TOTAL_REQ_CNT] > 0:
            data_fmt = "{:<32}  {:>10}  {:>12}  {:>12}  {:>12}  {:>9.4f}¥"

            output = [
                "按模型分类统计:",
                " 模型名称                          调用次数    输入Token     输出Token     Token总量     累计花费",
            ]
            for model_name, count in sorted(stats[REQ_CNT_BY_MODEL].items()):
                name = model_name[:29] + "..." if len(model_name) > 32 else model_name
                in_tokens = stats[IN_TOK_BY_MODEL][model_name]
                out_tokens = stats[OUT_TOK_BY_MODEL][model_name]
                tokens = stats[TOTAL_TOK_BY_MODEL][model_name]
                cost = stats[COST_BY_MODEL][model_name]
                output.append(data_fmt.format(name, count, in_tokens, out_tokens, tokens, cost))

            output.append("")
            return "\n".join(output)
        else:
            return ""

    def _format_chat_stat(self, stats: Dict[str, Any]) -> str:
        """
        格式化聊天统计数据
        """
        if stats[TOTAL_MSG_CNT] > 0:
            output = ["聊天消息统计:", " 联系人/群组名称                  消息数量"]
            for chat_id, count in sorted(stats[MSG_CNT_BY_CHAT].items()):
                output.append(f"{self.name_mapping[chat_id][0][:32]:<32}  {count:>10}")

            output.append("")
            return "\n".join(output)
        else:
            return ""

    def _generate_html_report(self, stat: dict[str, Any], now: datetime):
        """
        生成HTML格式的统计报告
        :param stat: 统计数据
        :param now: 基准当前时间
        :return: HTML格式的统计报告
        """

        tab_list = [
            f'<button class="tab-link" onclick="showTab(event, \'{period[0]}\')">{period[2]}</button>'
            for period in self.stat_period
        ]

        def _format_stat_data(stat_data: dict[str, Any], div_id: str, start_time: datetime) -> str:
            """
            格式化一个时间段的统计数据到html div块
            :param stat_data: 统计数据
            :param div_id: div的ID
            :param start_time: 统计时间段开始时间
            """
            # format总在线时间

            # 生成HTML
            return f"""
            <div id="{div_id}" class="tab-content">
                <p class="info-item">
                    <strong>统计时段: </strong>
                    {start_time.strftime("%Y-%m-%d %H:%M:%S")} ~ {now.strftime("%Y-%m-%d %H:%M:%S")}
                </p>
                <p class="info-item"><strong>总在线时间: </strong>{_format_online_time(stat_data[ONLINE_TIME])}</p>
                <p class="info-item"><strong>总消息数: </strong>{stat_data[TOTAL_MSG_CNT]}</p>
                <p class="info-item"><strong>总请求数: </strong>{stat_data[TOTAL_REQ_CNT]}</p>
                <p class="info-item"><strong>总花费: </strong>{stat_data[TOTAL_COST]:.4f} ¥</p>
                
                <h2>按模型分类统计</h2>
                <table>
                    <thead><tr><th>模型名称</th><th>调用次数</th><th>输入Token</th><th>输出Token</th><th>Token总量</th><th>累计花费</th></tr></thead>
                    <tbody>
                        {
                "\n".join(
                    [
                        f"<tr>"
                        f"<td>{model_name}</td>"
                        f"<td>{count}</td>"
                        f"<td>{stat_data[IN_TOK_BY_MODEL][model_name]}</td>"
                        f"<td>{stat_data[OUT_TOK_BY_MODEL][model_name]}</td>"
                        f"<td>{stat_data[TOTAL_TOK_BY_MODEL][model_name]}</td>"
                        f"<td>{stat_data[COST_BY_MODEL][model_name]:.4f} ¥</td>"
                        f"</tr>"
                        for model_name, count in sorted(stat_data[REQ_CNT_BY_MODEL].items())
                    ]
                )
            }
                    </tbody>
                </table>
                
                <h2>按请求类型分类统计</h2>
                <table>
                    <thead>
                        <tr><th>请求类型</th><th>调用次数</th><th>输入Token</th><th>输出Token</th><th>Token总量</th><th>累计花费</th></tr>
                    </thead>
                    <tbody>
                    {
                "\n".join(
                    [
                        f"<tr>"
                        f"<td>{req_type}</td>"
                        f"<td>{count}</td>"
                        f"<td>{stat_data[IN_TOK_BY_TYPE][req_type]}</td>"
                        f"<td>{stat_data[OUT_TOK_BY_TYPE][req_type]}</td>"
                        f"<td>{stat_data[TOTAL_TOK_BY_TYPE][req_type]}</td>"
                        f"<td>{stat_data[COST_BY_TYPE][req_type]:.4f} ¥</td>"
                        f"</tr>"
                        for req_type, count in sorted(stat_data[REQ_CNT_BY_TYPE].items())
                    ]
                )
            }
                    </tbody>
                </table>
    
                <h2>按用户分类统计</h2>
                <table>
                    <thead>
                        <tr><th>用户名称</th><th>调用次数</th><th>输入Token</th><th>输出Token</th><th>Token总量</th><th>累计花费</th></tr>
                    </thead>
                    <tbody>
                    {
                "\n".join(
                    [
                        f"<tr>"
                        f"<td>{user_id}</td>"
                        f"<td>{count}</td>"
                        f"<td>{stat_data[IN_TOK_BY_USER][user_id]}</td>"
                        f"<td>{stat_data[OUT_TOK_BY_USER][user_id]}</td>"
                        f"<td>{stat_data[TOTAL_TOK_BY_USER][user_id]}</td>"
                        f"<td>{stat_data[COST_BY_USER][user_id]:.4f} ¥</td>"
                        f"</tr>"
                        for user_id, count in sorted(stat_data[REQ_CNT_BY_USER].items())
                    ]
                )
            }
                    </tbody>
                </table>
    
                <h2>聊天消息统计</h2>
                <table>
                    <thead>
                        <tr><th>联系人/群组名称</th><th>消息数量</th></tr>
                    </thead>
                    <tbody>
                    {
                "\n".join(
                    [
                        f"<tr><td>{self.name_mapping[chat_id][0]}</td><td>{count}</td></tr>"
                        for chat_id, count in sorted(stat_data[MSG_CNT_BY_CHAT].items())
                    ]
                )
            }
                    </tbody>
                </table>
            </div>
            """

        tab_content_list = [
            _format_stat_data(stat[period[0]], period[0], now - period[1])
            for period in self.stat_period
            if period[0] != "all_time"
        ]

        tab_content_list.append(
            _format_stat_data(stat["all_time"], "all_time", datetime.fromtimestamp(local_storage["deploy_time"]))
        )

        html_template = (
            """
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>MaiBot运行统计报告</title>
    <style>
        body {
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
            margin: 0;
            padding: 20px;
            background-color: #f4f7f6;
            color: #333;
            line-height: 1.6;
        }
        .container {
            max-width: 900px;
            margin: 20px auto;
            background-color: #fff;
            padding: 25px;
            border-radius: 8px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
        }
        h1, h2 {
            color: #2c3e50;
            border-bottom: 2px solid #3498db;
            padding-bottom: 10px;
            margin-top: 0;
        }
        h1 {
            text-align: center;
            font-size: 2em;
        }
        h2 {
            font-size: 1.5em;
            margin-top: 30px;
        }
        p {
            margin-bottom: 10px;
        }
        .info-item {
            background-color: #ecf0f1;
            padding: 8px 12px;
            border-radius: 4px;
            margin-bottom: 8px;
            font-size: 0.95em;
        }
        .info-item strong {
            color: #2980b9;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin-top: 15px;
            font-size: 0.9em;
        }
        th, td {
            border: 1px solid #ddd;
            padding: 10px;
            text-align: left;
        }
        th {
            background-color: #3498db;
            color: white;
            font-weight: bold;
        }
        tr:nth-child(even) {
            background-color: #f9f9f9;
        }
        .footer {
            text-align: center;
            margin-top: 30px;
            font-size: 0.8em;
            color: #7f8c8d;
        }
        .tabs {
            overflow: hidden;
            background: #ecf0f1;
            display: flex;
        }
        .tabs button {
            background: inherit; border: none; outline: none;
            padding: 14px 16px; cursor: pointer;
            transition: 0.3s; font-size: 16px;
        }
        .tabs button:hover {
            background-color: #d4dbdc;
        }
        .tabs button.active {
            background-color: #b3bbbd;
        }
        .tab-content {
            display: none;
            padding: 20px;
            background-color: #fff;
            border: 1px solid #ccc;
        }
        .tab-content.active {
            display: block;
        }
    </style>
</head>
<body>
"""
            + f"""
    <div class="container">
        <h1>MaiBot运行统计报告</h1>
        <p class="info-item"><strong>统计截止时间:</strong> {now.strftime("%Y-%m-%d %H:%M:%S")}</p>

        <div class="tabs">
            {"\n".join(tab_list)}
        </div>

        {"\n".join(tab_content_list)}
    </div>
"""
            + """
<script>
    let i, tab_content, tab_links;
    tab_content = document.getElementsByClassName("tab-content");
    tab_links = document.getElementsByClassName("tab-link");
    
    tab_content[0].classList.add("active");
    tab_links[0].classList.add("active");

    function showTab(evt, tabName) {{
        for (i = 0; i < tab_content.length; i++) tab_content[i].classList.remove("active");
        for (i = 0; i < tab_links.length; i++) tab_links[i].classList.remove("active");
        document.getElementById(tabName).classList.add("active");
        evt.currentTarget.classList.add("active");
    }}
</script>
</body>
</html>
        """
        )

        with open(self.record_file_path, "w", encoding="utf-8") as f:
            f.write(html_template)