adminwindow.cpp

/**
 * @file adminwindow.cpp
 * @brief 管理员窗口实现文件
 *
 * 管理员窗口提供用户管理、图书管理、借阅管理、预约管理、统计报表和消息管理等功能。
 * 继承自QMainWindow，使用QStackedWidget管理多个功能页面。
 */

#include "adminwindow.h"
#include "statisticswidget.h"
#include "DataManager.h"
#include "Admin.h"
#include "User.h"
#include "Reader.h"
#include "StudentReader.h"
#include "TeacherReader.h"
#include "ExternalReader.h"
#include "Book.h"
#include "BorrowRecord.h"
#include "Reservation.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QWidget>
#include <QStackedWidget>
#include <QToolBar>
#include <QTableWidget>
#include <QLineEdit>
#include <QPushButton>
#include <QDialog>
#include <QIcon>
#include <QHeaderView>
#include <QAction>
#include <QActionGroup>
#include <QMessageBox>
#include <QInputDialog>
#include <QLabel>
#include <QDateTime>
#include <vector>

/**
 * @brief 构造函数
 * @param user 当前登录的管理员用户对象
 * @param parent 父窗口
 *
 * 初始化管理员窗口，设置窗口属性、工具栏和各个功能页面。
 */
AdminWindow::AdminWindow(::User *user, QWidget *parent)
    : QMainWindow(parent), currentUser(user), toolbar(nullptr), stackedWidget(nullptr), userWidget(nullptr), bookWidget(nullptr), borrowWidget(nullptr), reservationWidget(nullptr), userTable(nullptr), bookTable(nullptr), borrowTable(nullptr), reservationTable(nullptr), statisticsTable(nullptr), statisticsWidget(nullptr), userIdLineEdit(nullptr), userNameLineEdit(nullptr), userSearchBtn(nullptr), userAddBtn(nullptr), userDeleteBtn(nullptr), userUpdateBtn(nullptr), userClearBtn(nullptr), bookISBNLineEdit(nullptr), bookTitleLineEdit(nullptr), bookAuthorLineEdit(nullptr), bookCategoryLineEdit(nullptr), bookSearchBtn(nullptr), bookAddBtn(nullptr), bookDeleteBtn(nullptr), bookUpdateBtn(nullptr), bookClearBtn(nullptr), bookSortBtn(nullptr), bookSortByTimeBtn(nullptr), borrowISBNLineEdit(nullptr), borrowReaderIdLineEdit(nullptr), borrowSearchBtn(nullptr), borrowRenewAuditBtn(nullptr), processReservationBtn(nullptr), messageWidget(nullptr), messageTable(nullptr)
{
    // （设置窗口大小）：设置初始窗口大小为800x800
    resize(800, 800);
    // （设置窗口图标）：设置窗口图标为图书图标
    setWindowIcon(QIcon(":/image/book.png"));
    // （禁用关闭按钮）：移除窗口关闭按钮
    setWindowFlags(windowFlags() & ~Qt::WindowCloseButtonHint);
    // （设置窗口标题）：设置窗口标题为用户身份和姓名
    if (currentUser)
    {
        setWindowTitle(QString("%1 - %2").arg(currentUser->typeToIdentity()).arg(currentUser->getName()));
    }

    // （初始化工具栏）：初始化左侧工具栏
    setupToolbar();
    // （初始化中心部件）：初始化中心堆叠部件
    setupCentralWidget();

    // （默认显示）：默认显示用户管理界面
    onUserManagement();
}

/**
 * @brief 析构函数
 *
 * 释放窗口资源。
 */
AdminWindow::~AdminWindow()
{
}

/**
 * @brief 初始化工具栏
 *
 * 创建左侧工具栏，添加用户管理、图书管理、借阅管理、预约管理、统计报表、消息管理和退出登录按钮。
 */
void AdminWindow::setupToolbar()
{
    // （创建工具栏）：创建工具栏实例
    toolbar = new QToolBar(this);
    // （设置工具栏属性）：设置工具栏不可移动
    toolbar->setMovable(false);
    // （设置按钮样式）：设置按钮图标在上，文字在下
    toolbar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
    // （添加工具栏到窗口）：将工具栏添加到左侧
    addToolBar(Qt::LeftToolBarArea, toolbar);

    // （创建动作）：创建用户管理动作
    QAction *userAct = new QAction(QIcon(":/image/user.png"), "用户管理", this);
    // （创建动作）：创建图书管理动作
    QAction *bookAct = new QAction(QIcon(":/image/book2.png"), "图书管理", this);
    // （创建动作）：创建借阅管理动作
    QAction *borrowAct = new QAction(QIcon(":/image/borrow.png"), "借阅管理", this);
    // （创建动作）：创建预约管理动作
    QAction *reservationAct = new QAction(QIcon(":/image/reservation.png"), "预约管理", this);
    // （创建动作）：创建统计报表动作
    QAction *statisticsAct = new QAction(QIcon(":/image/report.png"), "统计报表", this);
    // （创建动作）：创建消息管理动作
    QAction *messageAct = new QAction(QIcon(":/image/message.png"), "消息管理", this);
    // （创建动作）：创建退出登录动作
    QAction *logoutAct = new QAction(QIcon(":/image/logout.png"), "退出登录", this);

    // （连接信号槽）：连接用户管理动作到槽函数
    connect(userAct, &QAction::triggered, this, &AdminWindow::onUserManagement);
    // （连接信号槽）：连接图书管理动作到槽函数
    connect(bookAct, &QAction::triggered, this, &AdminWindow::onBookManagement);
    // （连接信号槽）：连接借阅管理动作到槽函数
    connect(borrowAct, &QAction::triggered, this, &AdminWindow::onBorrowManagement);
    // （连接信号槽）：连接预约管理动作到槽函数
    connect(reservationAct, &QAction::triggered, this, &AdminWindow::onReservationManagement);
    // （连接信号槽）：连接统计报表动作到槽函数
    connect(statisticsAct, &QAction::triggered, this, &AdminWindow::onStatistics);
    // （连接信号槽）：连接消息管理动作到槽函数
    connect(messageAct, &QAction::triggered, this, &AdminWindow::onMessage);
    // （连接信号槽）：连接退出登录动作到槽函数
    connect(logoutAct, &QAction::triggered, this, &AdminWindow::onLogout);

    // （添加动作）：将动作添加到工具栏
    toolbar->addAction(userAct);
    toolbar->addAction(bookAct);
    toolbar->addAction(borrowAct);
    toolbar->addAction(reservationAct);
    toolbar->addAction(statisticsAct);
    toolbar->addAction(messageAct);
    toolbar->addAction(logoutAct);
}

/**
 * @brief 初始化中心部件
 *
 * 创建堆叠部件，管理用户管理、图书管理、借阅管理、预约管理、统计报表和消息管理等多个页面。
 */
void AdminWindow::setupCentralWidget()
{
    stackedWidget = new QStackedWidget(this);
    setCentralWidget(stackedWidget);

    setupUserTable();
    setupBookTable();
    setupBorrowTable();
    setupReservationTable();
    setupStatisticsTable();
    setupMessageWidget();

    stackedWidget->addWidget(userWidget);
    stackedWidget->addWidget(bookWidget);
    stackedWidget->addWidget(borrowWidget);
    stackedWidget->addWidget(reservationWidget);
    stackedWidget->addWidget(statisticsWidget);
    stackedWidget->addWidget(messageWidget);
}

/**
 * @brief 初始化用户表格
 *
 * 创建用户管理界面，包括操作区和用户表格，设置列数为8（ID、类型、姓名、密码、电话、邮箱、信用分、限制终止日期）。
 */
void AdminWindow::setupUserTable()
{
    // （创建用户管理容器）：创建用户管理界面的容器
    userWidget = new QWidget(this);
    QVBoxLayout *userMainLayout = new QVBoxLayout(userWidget);

    // （创建操作区容器）：创建操作区的容器
    QWidget *operationWidget = new QWidget(userWidget);
    QHBoxLayout *operationLayout = new QHBoxLayout(operationWidget);

    // （创建ID输入框）：创建用户ID查找输入框，设置提示文字
    userIdLineEdit = new QLineEdit(operationWidget);
    userIdLineEdit->setPlaceholderText("输入用户ID");
    userIdLineEdit->setFixedWidth(100);

    // （创建姓名输入框）：创建用户姓名查找输入框，设置提示文字
    userNameLineEdit = new QLineEdit(operationWidget);
    userNameLineEdit->setPlaceholderText("输入用户姓名");
    userNameLineEdit->setFixedWidth(120);

    // （创建按钮）：创建查找按钮
    userSearchBtn = new QPushButton("查找", operationWidget);
    // （创建按钮）：创建增加按钮
    userAddBtn = new QPushButton("增加", operationWidget);
    // （创建按钮）：创建删除按钮
    userDeleteBtn = new QPushButton("删除", operationWidget);
    // （创建按钮）：创建修改按钮
    userUpdateBtn = new QPushButton("修改", operationWidget);
    // （创建按钮）：创建清除按钮
    userClearBtn = new QPushButton("清除所有用户", operationWidget);

    // （创建角色下拉框）：创建用户角色筛选下拉框
    userRoleCombo = new QComboBox(operationWidget);
    userRoleCombo->addItem("全部角色");
    userRoleCombo->addItem("学生读者");
    userRoleCombo->addItem("教师读者");
    userRoleCombo->addItem("校外读者");

    // （设置布局）：将控件添加到操作区布局
    operationLayout->addWidget(userIdLineEdit);
    operationLayout->addWidget(userNameLineEdit);
    operationLayout->addWidget(userRoleCombo);
    operationLayout->addWidget(userSearchBtn);
    operationLayout->addWidget(userAddBtn);
    operationLayout->addWidget(userDeleteBtn);
    operationLayout->addWidget(userUpdateBtn);
    operationLayout->addWidget(userClearBtn);
    operationLayout->addStretch();

    // （创建表格）：创建用户表格实例
    userTable = new QTableWidget(userWidget);
    // （设置列数）：设置用户表格列数为9
    userTable->setColumnCount(9);
    // （设置表头）：设置用户表格表头
    userTable->setHorizontalHeaderLabels({"ID", "类型", "角色", "姓名", "密码", "电话", "邮箱", "信用分", "限制终止日期"});
    // （设置列调整模式）：列自动拉伸填充
    userTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    // （设置行调整模式）：行高根据内容自动调整
    userTable->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
    // （设置编辑属性）：表格只读，不可编辑
    userTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    // （设置选择行为）：选择整行
    userTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    // （设置选择模式）：单选模式
    userTable->setSelectionMode(QAbstractItemView::SingleSelection);

    // （设置主布局）：将操作区和表格添加到主布局
    userMainLayout->addWidget(operationWidget);
    userMainLayout->addWidget(userTable);

    // （连接按钮信号槽）：连接用户管理按钮信号槽
    connect(userSearchBtn, &QPushButton::clicked, this, &AdminWindow::onUserSearch);
    connect(userAddBtn, &QPushButton::clicked, this, &AdminWindow::onUserAdd);
    connect(userDeleteBtn, &QPushButton::clicked, this, &AdminWindow::onUserDelete);
    connect(userUpdateBtn, &QPushButton::clicked, this, &AdminWindow::onUserUpdate);
    connect(userClearBtn, &QPushButton::clicked, this, &AdminWindow::onUserClear);
    // （连接角色筛选信号槽）：角色下拉框改变时触发筛选
    connect(userRoleCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &AdminWindow::onUserRoleFilter);
}

/**
 * @brief 初始化图书表格
 *
 * 创建图书管理界面，包括操作区和图书表格，设置列数为11（ISBN、书名、作者、分类、库存、入库时间、借阅次数、逾期次数、当前借出、状态、预约人数）。
 */
void AdminWindow::setupBookTable()
{
    bookWidget = new QWidget(this);
    QVBoxLayout *bookMainLayout = new QVBoxLayout(bookWidget);

    QWidget *bookOperationWidget = new QWidget(bookWidget);
    QHBoxLayout *bookOperationLayout = new QHBoxLayout(bookOperationWidget);

    bookISBNLineEdit = new QLineEdit(bookOperationWidget);
    bookISBNLineEdit->setPlaceholderText("ISBN");
    bookISBNLineEdit->setFixedWidth(120);

    bookTitleLineEdit = new QLineEdit(bookOperationWidget);
    bookTitleLineEdit->setPlaceholderText("书名");
    bookTitleLineEdit->setFixedWidth(100);

    bookAuthorLineEdit = new QLineEdit(bookOperationWidget);
    bookAuthorLineEdit->setPlaceholderText("作者");
    bookAuthorLineEdit->setFixedWidth(100);

    bookCategoryLineEdit = new QLineEdit(bookOperationWidget);
    bookCategoryLineEdit->setPlaceholderText("分类");
    bookCategoryLineEdit->setFixedWidth(100);

    bookSearchBtn = new QPushButton("查找", bookOperationWidget);
    bookAddBtn = new QPushButton("增加", bookOperationWidget);
    bookDeleteBtn = new QPushButton("删除", bookOperationWidget);
    bookUpdateBtn = new QPushButton("修改", bookOperationWidget);
    bookClearBtn = new QPushButton("清除所有图书", bookOperationWidget);
    bookSortBtn = new QPushButton("按借阅次数排序", bookOperationWidget);
    bookSortByTimeBtn = new QPushButton("按入库时间排序", bookOperationWidget);

    bookOperationLayout->addWidget(bookISBNLineEdit);
    bookOperationLayout->addWidget(bookTitleLineEdit);
    bookOperationLayout->addWidget(bookAuthorLineEdit);
    bookOperationLayout->addWidget(bookCategoryLineEdit);
    bookOperationLayout->addWidget(bookSearchBtn);
    bookOperationLayout->addWidget(bookAddBtn);
    bookOperationLayout->addWidget(bookDeleteBtn);
    bookOperationLayout->addWidget(bookUpdateBtn);
    bookOperationLayout->addWidget(bookClearBtn);
    bookOperationLayout->addWidget(bookSortBtn);
    bookOperationLayout->addWidget(bookSortByTimeBtn);
    bookOperationLayout->addStretch();

    bookTable = new QTableWidget(bookWidget);
    bookTable->setColumnCount(11);
    bookTable->setHorizontalHeaderLabels({"ISBN", "书名", "作者", "分类", "库存", "入库时间", "借阅次数", "逾期次数", "当前借出", "状态", "预约人数"});
    bookTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    bookTable->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
    bookTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    bookTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    bookTable->setSelectionMode(QAbstractItemView::SingleSelection);

    bookMainLayout->addWidget(bookOperationWidget);
    bookMainLayout->addWidget(bookTable);

    connect(bookSearchBtn, &QPushButton::clicked, this, &AdminWindow::onBookSearch);
    connect(bookAddBtn, &QPushButton::clicked, this, &AdminWindow::onBookAdd);
    connect(bookDeleteBtn, &QPushButton::clicked, this, &AdminWindow::onBookDelete);
    connect(bookUpdateBtn, &QPushButton::clicked, this, &AdminWindow::onBookUpdate);
    connect(bookClearBtn, &QPushButton::clicked, this, &AdminWindow::onBookClear);
    connect(bookSortBtn, &QPushButton::clicked, this, &AdminWindow::onBookSort);
    connect(bookSortByTimeBtn, &QPushButton::clicked, this, &AdminWindow::onBookSortByTime);
}

/**
 * @brief 初始化借阅表格
 *
 * 创建借阅管理界面，包括操作区和借阅表格，设置列数为12（ISBN、书名、读者ID、读者姓名、借阅时间、应还时间、归还时间、状态、续借状态、罚款金额、已支付罚款、罚款状态）。
 */
void AdminWindow::setupBorrowTable()
{
    // （创建借阅管理容器）：创建借阅管理界面的容器
    borrowWidget = new QWidget(this);
    QVBoxLayout *borrowMainLayout = new QVBoxLayout(borrowWidget);

    // （创建操作区容器）：创建操作区的容器
    QWidget *borrowOperationWidget = new QWidget(borrowWidget);
    QHBoxLayout *borrowOperationLayout = new QHBoxLayout(borrowOperationWidget);

    // （创建按钮）：创建续借审核按钮
    borrowRenewAuditBtn = new QPushButton("续借审核", borrowOperationWidget);
    borrowOperationLayout->addWidget(borrowRenewAuditBtn);

    // （添加分隔线）
    QFrame *separator = new QFrame(borrowOperationWidget);
    separator->setFrameShape(QFrame::VLine);
    separator->setFrameShadow(QFrame::Sunken);
    borrowOperationLayout->addWidget(separator);

    // （创建ISBN输入框）：创建图书ISBN查找输入框
    borrowISBNLineEdit = new QLineEdit(borrowOperationWidget);
    borrowISBNLineEdit->setPlaceholderText("ISBN");
    borrowISBNLineEdit->setFixedWidth(120);

    // （创建书名输入框）：创建书名查找输入框
    borrowTitleLineEdit = new QLineEdit(borrowOperationWidget);
    borrowTitleLineEdit->setPlaceholderText("书名");
    borrowTitleLineEdit->setFixedWidth(150);

    // （创建读者ID输入框）：创建读者ID查找输入框
    borrowReaderIdLineEdit = new QLineEdit(borrowOperationWidget);
    borrowReaderIdLineEdit->setPlaceholderText("读者ID");
    borrowReaderIdLineEdit->setFixedWidth(100);

    // （创建借阅时间输入框）：创建借阅时间查找输入框
    borrowTimeLineEdit = new QLineEdit(borrowOperationWidget);
    borrowTimeLineEdit->setPlaceholderText("借阅时间");
    borrowTimeLineEdit->setFixedWidth(120);

    // （创建应还时间输入框）：创建应还时间查找输入框
    borrowDueTimeLineEdit = new QLineEdit(borrowOperationWidget);
    borrowDueTimeLineEdit->setPlaceholderText("应还时间");
    borrowDueTimeLineEdit->setFixedWidth(120);

    // （创建归还时间输入框）：创建归还时间查找输入框
    borrowReturnTimeLineEdit = new QLineEdit(borrowOperationWidget);
    borrowReturnTimeLineEdit->setPlaceholderText("归还时间");
    borrowReturnTimeLineEdit->setFixedWidth(120);

    // （创建状态输入框）：创建状态查找输入框
    borrowStatusEdit = new QLineEdit(borrowOperationWidget);
    borrowStatusEdit->setPlaceholderText("状态");
    borrowStatusEdit->setFixedWidth(80);

    // （创建续借状态下拉框）：创建续借状态查找下拉框
    borrowRenewCombo = new QComboBox(borrowOperationWidget);
    borrowRenewCombo->addItem("");
    borrowRenewCombo->addItem("无申请");
    borrowRenewCombo->addItem("待审核");
    borrowRenewCombo->addItem("已通过");
    borrowRenewCombo->addItem("已拒绝");
    borrowRenewCombo->setFixedWidth(80);

    // （创建罚款状态下拉框）：创建罚款状态查找下拉框
    borrowFineCombo = new QComboBox(borrowOperationWidget);
    borrowFineCombo->addItem("");
    borrowFineCombo->addItem("未支付");
    borrowFineCombo->addItem("已支付");
    borrowFineCombo->setFixedWidth(80);

    // （创建按钮）：创建查找按钮
    borrowSearchBtn = new QPushButton("查找", borrowOperationWidget);

    // （设置布局）：将控件添加到操作区布局
    borrowOperationLayout->addWidget(borrowISBNLineEdit);
    borrowOperationLayout->addWidget(borrowTitleLineEdit);
    borrowOperationLayout->addWidget(borrowReaderIdLineEdit);
    borrowOperationLayout->addWidget(borrowTimeLineEdit);
    borrowOperationLayout->addWidget(borrowDueTimeLineEdit);
    borrowOperationLayout->addWidget(borrowReturnTimeLineEdit);
    borrowOperationLayout->addWidget(borrowStatusEdit);
    borrowOperationLayout->addWidget(borrowRenewCombo);
    borrowOperationLayout->addWidget(borrowFineCombo);
    borrowOperationLayout->addWidget(borrowSearchBtn);
    borrowOperationLayout->addStretch();

    // （创建表格）：创建借阅表格实例
    borrowTable = new QTableWidget(borrowWidget);
    // （设置列数）：设置借阅表格列数为12
    borrowTable->setColumnCount(11);
    // （设置表头）：设置借阅表格表头
    borrowTable->setHorizontalHeaderLabels({"ISBN", "书名", "读者ID", "读者姓名", "借阅时间", "应还时间", "状态", "续借状态", "续借次数", "罚款金额", "已支付罚款"});
    // （设置列调整模式）：列自动拉伸填充
    borrowTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    // （设置行调整模式）：行高根据内容自动调整
    borrowTable->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
    // （设置编辑属性）：表格只读，不可编辑
    borrowTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    // （设置选择行为）：选择整行
    borrowTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    // （设置选择模式）：单选模式
    borrowTable->setSelectionMode(QAbstractItemView::SingleSelection);

    // （设置主布局）：将操作区和表格添加到主布局
    borrowMainLayout->addWidget(borrowOperationWidget);
    borrowMainLayout->addWidget(borrowTable);

    // （连接按钮信号槽）：连接借阅管理按钮信号槽
    connect(borrowSearchBtn, &QPushButton::clicked, this, &AdminWindow::onBorrowSearch);
    connect(borrowRenewAuditBtn, &QPushButton::clicked, this, &AdminWindow::onBorrowRenewAudit);
}

/**
 * @brief 初始化预约表格
 *
 * 创建预约管理界面，包括操作区和预约表格，设置列数为4（ISBN、读者ID、预约时间、状态）。
 */
void AdminWindow::setupReservationTable()
{
    reservationWidget = new QWidget(this);
    QVBoxLayout *reservationMainLayout = new QVBoxLayout(reservationWidget);

    QWidget *reservationOperationWidget = new QWidget(reservationWidget);
    QHBoxLayout *reservationOperationLayout = new QHBoxLayout(reservationOperationWidget);

    processReservationBtn = new QPushButton("审核预约", reservationOperationWidget);

    QFrame *separator = new QFrame(reservationOperationWidget);
    separator->setFrameShape(QFrame::VLine);
    separator->setFrameShadow(QFrame::Sunken);
    reservationOperationLayout->addWidget(separator);

    reservationISBNLineEdit = new QLineEdit(reservationOperationWidget);
    reservationISBNLineEdit->setPlaceholderText("ISBN");
    reservationISBNLineEdit->setFixedWidth(120);

    reservationReaderIdLineEdit = new QLineEdit(reservationOperationWidget);
    reservationReaderIdLineEdit->setPlaceholderText("读者ID");
    reservationReaderIdLineEdit->setFixedWidth(100);

    reservationTimeLineEdit = new QLineEdit(reservationOperationWidget);
    reservationTimeLineEdit->setPlaceholderText("预约时间");
    reservationTimeLineEdit->setFixedWidth(140);

    reservationStatusCombo = new QComboBox(reservationOperationWidget);
    reservationStatusCombo->addItem("");
    reservationStatusCombo->addItem("待审核");
    reservationStatusCombo->addItem("审核成功");
    reservationStatusCombo->setFixedWidth(80);

    QPushButton *searchReservationBtn = new QPushButton("查询预约", reservationOperationWidget);

    reservationOperationLayout->addWidget(processReservationBtn);
    reservationOperationLayout->addWidget(separator);
    reservationOperationLayout->addWidget(reservationISBNLineEdit);
    reservationOperationLayout->addWidget(reservationReaderIdLineEdit);
    reservationOperationLayout->addWidget(reservationTimeLineEdit);
    reservationOperationLayout->addWidget(reservationStatusCombo);
    reservationOperationLayout->addWidget(searchReservationBtn);
    reservationOperationLayout->addStretch();

    reservationTable = new QTableWidget(reservationWidget);
    reservationTable->setColumnCount(4);
    reservationTable->setHorizontalHeaderLabels({"ISBN", "读者ID", "预约时间", "状态"});
    reservationTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    reservationTable->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
    reservationTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    reservationTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    reservationTable->setSelectionMode(QAbstractItemView::SingleSelection);

    reservationMainLayout->addWidget(reservationOperationWidget);
    reservationMainLayout->addWidget(reservationTable);

    connect(processReservationBtn, &QPushButton::clicked, this, &AdminWindow::onProcessReservation);
    connect(searchReservationBtn, &QPushButton::clicked, this, &AdminWindow::onSearchReservation);
}

/**
 * @brief 初始化统计报表
 *
 * 创建统计报表界面，使用StatisticsWidget组件。
 */
void AdminWindow::setupStatisticsTable()
{
    statisticsWidget = new StatisticsWidget(this, currentUser);
}

/**
 * @brief 加载用户数据
 *
 * 从数据管理器获取所有用户数据，并显示在用户表格中。
 */
void AdminWindow::loadUserData()
{
    DataManager *dm = DataManager::getInstance();
    userTable->setRowCount(0);

    std::vector<::User *> users = dm->getUsers();

    for (::User *user : users)
    {
        int row = userTable->rowCount();
        userTable->insertRow(row);

        userTable->setItem(row, 0, new QTableWidgetItem(user->getID()));
        userTable->setItem(row, 1, new QTableWidgetItem(user->getType() == 1 ? "管理员" : "读者"));

        // （显示角色）：管理员显示"-"，读者显示具体角色
        if (user->getType() == 2)
        {
            ::Reader *reader = dynamic_cast<::Reader *>(user);
            if (reader)
            {
                userTable->setItem(row, 2, new QTableWidgetItem(reader->getRoleString()));
            }
            else
            {
                userTable->setItem(row, 2, new QTableWidgetItem("-"));
            }
        }
        else
        {
            userTable->setItem(row, 2, new QTableWidgetItem("-"));
        }

        userTable->setItem(row, 3, new QTableWidgetItem(user->getName()));
        userTable->setItem(row, 4, new QTableWidgetItem(user->getPassword()));
        userTable->setItem(row, 5, new QTableWidgetItem(user->getPhone()));
        userTable->setItem(row, 6, new QTableWidgetItem(user->getEmail()));

        if (user->getType() == 2)
        {
            ::Reader *reader = dynamic_cast<::Reader *>(user);
            if (reader)
            {
                userTable->setItem(row, 7, new QTableWidgetItem(QString::number(reader->getCreditScore())));

                QDateTime banUntil = reader->getBanUntil();
                if (banUntil.isValid())
                {
                    userTable->setItem(row, 8, new QTableWidgetItem(banUntil.toString("yyyy-MM-dd HH:mm:ss")));
                }
                else
                {
                    userTable->setItem(row, 8, new QTableWidgetItem("-"));
                }
            }
            else
            {
                userTable->setItem(row, 7, new QTableWidgetItem("-"));
                userTable->setItem(row, 8, new QTableWidgetItem("-"));
            }
        }
        else
        {
            userTable->setItem(row, 7, new QTableWidgetItem("-"));
            userTable->setItem(row, 8, new QTableWidgetItem("-"));
        }
    }
}

/**
 * @brief 加载图书数据
 *
 * 从数据管理器获取所有图书数据，并显示在图书表格中。
 */
void AdminWindow::loadBookData()
{
    DataManager *dm = DataManager::getInstance();
    bookTable->setRowCount(0);

    Admin *admin = dynamic_cast<Admin *>(currentUser);
    if (admin)
    {
        std::vector<const Book *> books = admin->findBook("", "", "", "");
        for (const auto *book : books)
        {
            int row = bookTable->rowCount();
            bookTable->insertRow(row);
            bookTable->setItem(row, 0, new QTableWidgetItem(book->getISBN()));
            bookTable->setItem(row, 1, new QTableWidgetItem(book->getTitle()));
            bookTable->setItem(row, 2, new QTableWidgetItem(book->getAuthor()));
            bookTable->setItem(row, 3, new QTableWidgetItem(book->getCategory()));
            bookTable->setItem(row, 4, new QTableWidgetItem(QString::number(book->getStock())));
            bookTable->setItem(row, 5, new QTableWidgetItem(book->getInStockTime().toString("yyyy-MM-dd HH:mm:ss")));
            bookTable->setItem(row, 6, new QTableWidgetItem(QString::number(book->getBorrowCount())));
            bookTable->setItem(row, 7, new QTableWidgetItem(QString::number(book->getOverdueReturnCount())));
            bookTable->setItem(row, 8, new QTableWidgetItem(QString::number(book->getCurrentBorrowed())));
            bookTable->setItem(row, 9, new QTableWidgetItem(book->getStatus()));
            bookTable->setItem(row, 10, new QTableWidgetItem(QString::number(book->getReservationCount())));
        }
    }
}

/**
 * @brief 图书查找
 *
 * 根据ISBN、书名、作者和分类条件查找图书，并显示在图书表格中。
 */
void AdminWindow::onBookSearch()
{
    QString isbn = bookISBNLineEdit->text().trimmed();
    QString title = bookTitleLineEdit->text().trimmed();
    QString author = bookAuthorLineEdit->text().trimmed();
    QString category = bookCategoryLineEdit->text().trimmed();

    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        std::vector<const Book *> results = admin->findBook(isbn, title, author, category);
        displayBooks(results);
    }
}

/**
 * @brief 显示图书
 * @param books 图书列表
 *
 * 将图书数据显示到图书表格中。
 */
void AdminWindow::displayBooks(const std::vector<const Book *> &books)
{
    bookTable->setRowCount(0);
    for (const auto *book : books)
    {
        int row = bookTable->rowCount();
        bookTable->insertRow(row);
        bookTable->setItem(row, 0, new QTableWidgetItem(book->getISBN()));
        bookTable->setItem(row, 1, new QTableWidgetItem(book->getTitle()));
        bookTable->setItem(row, 2, new QTableWidgetItem(book->getAuthor()));
        bookTable->setItem(row, 3, new QTableWidgetItem(book->getCategory()));
        bookTable->setItem(row, 4, new QTableWidgetItem(QString::number(book->getStock())));
        bookTable->setItem(row, 5, new QTableWidgetItem(book->getInStockTime().toString("yyyy-MM-dd HH:mm:ss")));
        bookTable->setItem(row, 6, new QTableWidgetItem(QString::number(book->getBorrowCount())));
        bookTable->setItem(row, 7, new QTableWidgetItem(QString::number(book->getOverdueReturnCount())));
        bookTable->setItem(row, 8, new QTableWidgetItem(QString::number(book->getCurrentBorrowed())));
        bookTable->setItem(row, 9, new QTableWidgetItem(book->getStatus()));
        bookTable->setItem(row, 10, new QTableWidgetItem(QString::number(book->getReservationCount())));
    }
}

/**
 * @brief 添加图书
 *
 * 弹出对话框输入图书信息，添加新图书或增加已有图书的库存。
 */
void AdminWindow::onBookAdd()
{
    QPair<QString, bool> result = showInputDialog("增加图书", "请输入图书ISBN：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString isbn = result.first;

    result = showInputDialog("增加图书", "请输入图书书名：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString title = result.first;

    result = showInputDialog("增加图书", "请输入图书作者：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString author = result.first;

    result = showInputDialog("增加图书", "请输入图书分类：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString category = result.first;

    result = showInputDialog("增加图书", "请输入图书库存数量：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    bool ok;
    int stock = result.first.toInt(&ok);
    if (!ok || stock < 0)
    {
        QMessageBox msgBox(QMessageBox::Warning, "错误", "库存数量必须是大于等于0的整数！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }

    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        int addResult = admin->addBook(isbn, title, author, category, stock);

        std::vector<const Book *> books = admin->findAllBook();
        displayBooks(books);

        if (addResult == -1)
        {
            QMessageBox::warning(this, "警告", QString("ISBN %1 对应的书已存在，请重试").arg(isbn));
        }
        else if (addResult == 1)
        {
            QMessageBox::information(this, "成功", "图书库存已增加！");

            // 发送消息：库存增加
            DataManager *dm = DataManager::getInstance();
            QString msgContent = QString("管理员%1增加了图书库存：%2（ISBN: %3, 作者: %4, 分类: %5, 库存: %6）")
                                     .arg(currentUser->getName())
                                     .arg(title)
                                     .arg(isbn)
                                     .arg(author)
                                     .arg(category)
                                     .arg(stock);
            dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);
        }
        else
        {
            QMessageBox::information(this, "成功", "图书添加成功！");

            // 发送消息：新增图书
            DataManager *dm = DataManager::getInstance();
            QString msgContent = QString("管理员%1添加了新图书：%2（ISBN: %3, 作者: %4, 分类: %5, 库存: %6）")
                                     .arg(currentUser->getName())
                                     .arg(title)
                                     .arg(isbn)
                                     .arg(author)
                                     .arg(category)
                                     .arg(stock);
            dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);
        }
    }
}

// （图书删除）：删除按钮点击处理
void AdminWindow::onBookDelete()
{
    QPair<QString, bool> isbnResult = showInputDialog("删除图书", "请输入要删除的图书ISBN：", true);
    if (isbnResult.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书删除已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString isbn = isbnResult.first;

    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (!admin)
    {
        return;
    }

    DataManager *dm = DataManager::getInstance();
    Book *book = dm->findBookByISBN(isbn);
    if (book == nullptr)
    {
        QMessageBox::warning(this, "失败", QString("不存在ISBN %1，请重试").arg(isbn));
        return;
    }

    QPair<QString, bool> stockResult = showInputDialog("删除图书", "请输入要减少的库存数目：", true);
    if (stockResult.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书删除已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    int decreaseStock = stockResult.first.toInt();

    // 保存图书信息（删除前获取）
    QString bookTitle = book->getTitle();
    QString bookAuthor = book->getAuthor();
    QString bookCategory = book->getCategory();
    int bookStock = book->getStock();

    int deleteResult = admin->deleteBook(isbn, decreaseStock);

    if (deleteResult == 0)
    {
        std::vector<const Book *> books = admin->findAllBook();
        displayBooks(books);
        QMessageBox::information(this, "成功", "图书删除成功！");

        // 发送消息：图书删除（已删除记录）
        DataManager *dm = DataManager::getInstance();
        QString msgContent = QString("管理员%1删除了图书：%2（ISBN: %3, 作者: %4, 分类: %5, 库存: %6）- 已删除记录")
                                 .arg(currentUser->getName())
                                 .arg(bookTitle)
                                 .arg(isbn)
                                 .arg(bookAuthor)
                                 .arg(bookCategory)
                                 .arg(bookStock);
        dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);
    }
    else if (deleteResult == 1)
    {
        std::vector<const Book *> books = admin->findAllBook();
        displayBooks(books);
        QMessageBox::information(this, "成功", "图书库存已减少！");

        // 发送消息：库存减少
        DataManager *dm = DataManager::getInstance();
        QString msgContent = QString("管理员%1减少了图书库存：%2（ISBN: %3, 作者: %4, 分类: %5, 库存: %6）- 减少%7本")
                                 .arg(currentUser->getName())
                                 .arg(book->getTitle())
                                 .arg(isbn)
                                 .arg(book->getAuthor())
                                 .arg(book->getCategory())
                                 .arg(book->getStock())
                                 .arg(decreaseStock);
        dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);
    }
    else if (deleteResult == -2)
    {
        QMessageBox::warning(this, "失败", "当前存在预约或借出，无法删除！");
    }
}

/**
 * @brief 修改图书
 *
 * 弹出对话框输入修改后的图书信息，修改已有图书的ISBN、书名、作者和分类。
 */
void AdminWindow::onBookUpdate()
{
    QPair<QString, bool> result = showInputDialog("修改图书", "请输入要修改的图书ISBN：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString oldIsbn = result.first;

    DataManager *dm = DataManager::getInstance();
    Book *foundBook = dm->findBookByISBN(oldIsbn);
    if (!foundBook)
    {
        QMessageBox::warning(this, "失败", QString("不存在ISBN %1，请重试").arg(oldIsbn));
        return;
    }

    // 检查是否有预约或借出
    if (foundBook->getReservationCount() > 0 || foundBook->getCurrentBorrowed() > 0)
    {
        QMessageBox::warning(this, "失败", "当前存在预约或借出，无法修改！");
        return;
    }

    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (!admin)
    {
        return;
    }

    result = showInputDialog("修改图书", "请输入修改后的图书ISBN：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString newIsbn = result.first;

    result = showInputDialog("修改图书", "请输入修改后的图书书名：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString title = result.first;

    result = showInputDialog("修改图书", "请输入修改后的图书作者：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString author = result.first;

    result = showInputDialog("修改图书", "请输入修改后的图书分类：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString category = result.first;

    result = showInputDialog("修改图书", "请输入修改后的图书库存数量：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "图书修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    bool ok;
    int stock = result.first.toInt(&ok);
    if (!ok || stock < 0)
    {
        QMessageBox msgBox(QMessageBox::Warning, "错误", "库存数量必须是大于等于0的整数！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }

    QDateTime inStockTime = QDateTime::currentDateTime();

    int updateResult = admin->updateBook(oldIsbn, newIsbn, title, author, category, stock, inStockTime);

    if (updateResult == 0)
    {
        std::vector<const Book *> books = admin->findAllBook();
        displayBooks(books);
        QMessageBox::information(this, "成功", "图书修改成功！");

        // 发送消息：图书修改
        DataManager *dm = DataManager::getInstance();
        QString msgContent = QString("管理员%1修改了图书信息：%2（ISBN: %3, 作者: %4, 分类: %5, 库存: %6）→ %7（ISBN: %8, 作者: %9, 分类: %10, 库存: %11）")
                                 .arg(currentUser->getName())
                                 .arg(foundBook->getTitle())
                                 .arg(oldIsbn)
                                 .arg(foundBook->getAuthor())
                                 .arg(foundBook->getCategory())
                                 .arg(foundBook->getStock())
                                 .arg(title)
                                 .arg(newIsbn)
                                 .arg(title)
                                 .arg(author)
                                 .arg(category)
                                 .arg(stock);
        dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);
    }
    else if (updateResult == -3)
    {
        QMessageBox::warning(this, "失败", QString("新ISBN %1 已存在，请重试").arg(newIsbn));
    }
}

/**
 * @brief 清除图书
 *
 * 清除所有图书信息，需要二次确认。若存在预约或借出的图书则无法清除。
 */
void AdminWindow::onBookClear()
{
    DataManager *dm = DataManager::getInstance();
    std::vector<Book> &books = dm->getBooks();
    for (auto &book : books)
    {
        if (book.getReservationCount() > 0 || book.getCurrentBorrowed() > 0)
        {
            QMessageBox::warning(this, "失败", "存在预约或借出的图书，无法清除！");
            return;
        }
    }

    QMessageBox warningBox(QMessageBox::Warning, "警告", "确定要清除所有图书信息吗？此操作不可恢复！", QMessageBox::NoButton, this);
    QAbstractButton *yesBtn1 = warningBox.addButton("是", QMessageBox::YesRole);
    warningBox.addButton("否", QMessageBox::NoRole);
    warningBox.exec();
    if (warningBox.clickedButton() == yesBtn1)
    {
        QMessageBox confirmBox(QMessageBox::Question, "确认", "再次确认：是否真的要清除所有图书？", QMessageBox::NoButton, this);
        QAbstractButton *yesBtn2 = confirmBox.addButton("是", QMessageBox::YesRole);
        confirmBox.addButton("否", QMessageBox::NoRole);
        confirmBox.exec();
        if (confirmBox.clickedButton() == yesBtn2)
        {
            ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
            if (admin)
            {
                admin->clearBook();
                displayBooks(std::vector<const Book *>());
            }

            QMessageBox msgBox(QMessageBox::Information, "成功", "已清除所有图书！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
        }
    }
}

/**
 * @brief 按借阅次数排序
 *
 * 将图书按借阅次数从高到低排序显示。
 */
void AdminWindow::onBookSort()
{
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        std::vector<const Book *> sortedBooks = admin->sortBookByBorrowCount();
        displayBooks(sortedBooks);

        QMessageBox msgBox(QMessageBox::Information, "成功", "已按借阅次数排序！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();

        DataManager *dm = DataManager::getInstance();
        QString msgContent = QString("管理员%1对图书按借阅次数进行了排序").arg(currentUser->getName());
        dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);
    }
}

/**
 * @brief 按入库时间排序
 *
 * 将图书按入库时间排序显示。
 */
void AdminWindow::onBookSortByTime()
{
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        std::vector<const Book *> sortedBooks = admin->sortBookByInStockTime();
        displayBooks(sortedBooks);

        QMessageBox msgBox(QMessageBox::Information, "成功", "已按入库时间排序！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();

        DataManager *dm = DataManager::getInstance();
        QString msgContent = QString("管理员%1对图书按入库时间进行了排序").arg(currentUser->getName());
        dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);
    }
}

/**
 * @brief 加载借阅数据
 *
 * 从数据管理器获取所有借阅记录，并显示在借阅表格中。
 */
void AdminWindow::loadBorrowData()
{
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        std::vector<BorrowRecord> records = admin->viewBorrowRecords();
        displayBorrowRecords(records);
    }
}

/**
 * @brief 借阅查找
 *
 * 根据ISBN、书名、读者ID、借阅时间、应还时间、归还时间、状态、罚款状态和续借状态等条件查找借阅记录。
 */
void AdminWindow::onBorrowSearch()
{
    QString isbn = borrowISBNLineEdit->text().trimmed();
    QString title = borrowTitleLineEdit->text().trimmed();
    QString readerId = borrowReaderIdLineEdit->text().trimmed();
    QString time = borrowTimeLineEdit->text().trimmed();
    QString dueTime = borrowDueTimeLineEdit->text().trimmed();
    QString returnTime = borrowReturnTimeLineEdit->text().trimmed();
    QString status = borrowStatusEdit->text().trimmed();
    QString fineStatus = borrowFineCombo->currentText();
    QString renewStatus = borrowRenewCombo->currentText();

    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        std::vector<BorrowRecord> records = admin->viewBorrowRecords();
        DataManager *dm = DataManager::getInstance();

        std::vector<BorrowRecord> filtered;
        for (const auto &record : records)
        {
            bool match = true;

            if (!isbn.isEmpty() && !record.getISBN().contains(isbn))
                match = false;

            if (!title.isEmpty())
            {
                Book *book = dm->findBookByISBN(record.getISBN());
                if (!book || !book->getTitle().contains(title))
                    match = false;
            }

            if (!readerId.isEmpty() && !record.getReaderID().contains(readerId))
                match = false;

            if (!time.isEmpty() && !record.getBorrowTime().toString("yyyy-MM-dd").contains(time))
                match = false;

            if (!dueTime.isEmpty() && !record.getDueTime().toString("yyyy-MM-dd").contains(dueTime))
                match = false;

            // 归还记录会被删除，所以不需要搜索归还时间

            if (!status.isEmpty())
            {
                QString recordStatus;
                if (record.calculateOverdueDays() > 0)
                    recordStatus = QString("逾期%1天").arg(record.calculateOverdueDays());
                else
                    recordStatus = "借阅中";

                if (!recordStatus.contains(status))
                    match = false;
            }

            if (!fineStatus.isEmpty())
            {
                BorrowRecord::FineStatus fs = record.getFineStatus();
                if (fineStatus == "未支付" && fs != BorrowRecord::FineStatus::UNPAID)
                    match = false;
                if (fineStatus == "已支付" && fs != BorrowRecord::FineStatus::PAID)
                    match = false;
            }

            if (!renewStatus.isEmpty())
            {
                BorrowRecord::RenewStatus rs = record.getRenewStatus();
                if (renewStatus == "无申请" && rs != BorrowRecord::RenewStatus::NONE)
                    match = false;
                if (renewStatus == "待审核" && rs != BorrowRecord::RenewStatus::PENDING)
                    match = false;
                if (renewStatus == "已通过" && rs != BorrowRecord::RenewStatus::APPROVED)
                    match = false;
                if (renewStatus == "已拒绝" && rs != BorrowRecord::RenewStatus::REJECTED)
                    match = false;
            }

            if (match)
                filtered.push_back(record);
        }
        displayBorrowRecords(filtered);
    }
}

/**
 * @brief 显示借阅记录
 * @param records 借阅记录列表
 *
 * 将借阅记录显示到借阅表格中，包括ISBN、书名、读者ID、读者姓名、借阅时间、应还时间、归还时间、状态、续借状态、罚款金额、已支付罚款和罚款状态。
 */
void AdminWindow::displayBorrowRecords(const std::vector<BorrowRecord> &records)
{
    borrowTable->setRowCount(0);
    DataManager *dm = DataManager::getInstance();

    for (const auto &record : records)
    {
        int row = borrowTable->rowCount();
        borrowTable->insertRow(row);

        borrowTable->setItem(row, 0, new QTableWidgetItem(record.getISBN()));

        Book *book = dm->findBookByISBN(record.getISBN());
        QString bookTitle = book ? book->getTitle() : "未知";
        borrowTable->setItem(row, 1, new QTableWidgetItem(bookTitle));

        borrowTable->setItem(row, 2, new QTableWidgetItem(record.getReaderID()));

        ::User *user = dm->findUserById(record.getReaderID());
        QString userName = user ? user->getName() : "未知";
        borrowTable->setItem(row, 3, new QTableWidgetItem(userName));

        borrowTable->setItem(row, 4, new QTableWidgetItem(record.getBorrowTime().toString("yyyy-MM-dd HH:mm:ss")));
        borrowTable->setItem(row, 5, new QTableWidgetItem(record.getDueTime().toString("yyyy-MM-dd HH:mm:ss")));

        QString status = "借阅中";
        if (record.calculateOverdueDays() > 0)
        {
            status = QString("逾期%1天").arg(record.calculateOverdueDays());
        }
        borrowTable->setItem(row, 6, new QTableWidgetItem(status));

        QString renewStatus;
        switch (record.getRenewStatus())
        {
        case BorrowRecord::RenewStatus::NONE:
            renewStatus = "无申请";
            break;
        case BorrowRecord::RenewStatus::PENDING:
            renewStatus = "待审核";
            break;
        case BorrowRecord::RenewStatus::APPROVED:
            renewStatus = "已通过";
            break;
        case BorrowRecord::RenewStatus::REJECTED:
            renewStatus = "已拒绝";
            break;
        default:
            renewStatus = "未知";
        }
        borrowTable->setItem(row, 7, new QTableWidgetItem(renewStatus));

        borrowTable->setItem(row, 8, new QTableWidgetItem(QString::number(record.getRenewCount())));

        // 罚款信息（从读者策略获取罚款标准）
        user = dm->findUserById(record.getReaderID());
        ::Reader *reader = dynamic_cast<::Reader *>(user);
        double finePerDay = reader ? reader->getFinePerDay() : 1.0;

        double fineAmount = record.calculateFine(finePerDay);
        double paidFine = record.getPaidFine();
        borrowTable->setItem(row, 9, new QTableWidgetItem(QString::number(fineAmount, 'f', 2) + "元"));
        borrowTable->setItem(row, 10, new QTableWidgetItem(QString::number(paidFine, 'f', 2) + "元"));
    }
}

/**
 * @brief 续借审核
 *
 * 对选中的借阅记录进行续借审核，可以通过或拒绝续借申请。
 */
void AdminWindow::onBorrowRenewAudit()
{
    int currentRow = borrowTable->currentRow();
    if (currentRow < 0)
    {
        QMessageBox::warning(this, "提示", "请先选择一条借阅记录！");
        return;
    }

    QString isbn = borrowTable->item(currentRow, 0)->text();
    QString readerId = borrowTable->item(currentRow, 2)->text();
    QString status = borrowTable->item(currentRow, 7)->text();

    if (status == "已归还")
    {
        QMessageBox::warning(this, "提示", "该图书已归还，无需续借审核！");
        return;
    }

    QDialog dialog(this);
    dialog.setWindowTitle("续借审核");
    QVBoxLayout layout(&dialog);

    QLabel *infoLabel = new QLabel(QString("ISBN: %1\n读者ID: %2\n当前状态: %3").arg(isbn).arg(readerId).arg(status), &dialog);
    layout.addWidget(infoLabel);

    QHBoxLayout btnLayout;
    QPushButton *approveBtn = new QPushButton("审核成功", &dialog);
    QPushButton *rejectBtn = new QPushButton("审核失败", &dialog);
    QPushButton *cancelBtn = new QPushButton("取消", &dialog);
    btnLayout.addWidget(approveBtn);
    btnLayout.addWidget(rejectBtn);
    btnLayout.addWidget(cancelBtn);
    layout.addLayout(&btnLayout);

    connect(approveBtn, &QPushButton::clicked, &dialog, [&]()
            { dialog.done(1); });
    connect(rejectBtn, &QPushButton::clicked, &dialog, [&]()
            { dialog.done(2); });
    connect(cancelBtn, &QPushButton::clicked, &dialog, [&]()
            { dialog.done(0); });

    int result = dialog.exec();

    if (result == 0)
        return;

    DataManager *dm = DataManager::getInstance();
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);

    if (result == 1)
    {
        bool success = admin->renewBook(isbn, readerId, true);
        if (success)
        {
            loadBorrowData();
            QMessageBox::information(this, "成功", "续借审核成功！已延长借阅期限30天。");
        }
        else
        {
            QMessageBox::warning(this, "失败", "续借审核失败！该记录没有待审核的续借申请。");
        }
    }
    else if (result == 2)
    {
        bool success = admin->renewBook(isbn, readerId, false);
        if (success)
        {
            loadBorrowData();
            QMessageBox::information(this, "提示", "已拒绝续借申请并通知读者。");
        }
        else
        {
            QMessageBox::warning(this, "失败", "续借审核失败！该记录没有待审核的续借申请。");
        }
    }
}

/**
 * @brief 加载预约数据
 *
 * 从数据管理器获取所有预约数据，并显示在预约表格中。
 */
void AdminWindow::loadReservationData()
{
    DataManager *dm = DataManager::getInstance();
    reservationTable->setRowCount(0);

    std::vector<Reservation> reservations = dm->getReservations();

    for (const auto &reservation : reservations)
    {
        int row = reservationTable->rowCount();
        reservationTable->insertRow(row);

        reservationTable->setItem(row, 0, new QTableWidgetItem(reservation.getISBN()));
        reservationTable->setItem(row, 1, new QTableWidgetItem(reservation.getReaderID()));
        reservationTable->setItem(row, 2, new QTableWidgetItem(reservation.getReserveTime().toString("yyyy-MM-dd HH:mm:ss")));
        reservationTable->setItem(row, 3, new QTableWidgetItem(reservation.getStatusString()));
    }
}

/**
 * @brief 加载统计数据
 *
 * 更新统计报表界面的统计数据。
 */
void AdminWindow::loadStatisticsData()
{
    if (statisticsWidget)
    {
        statisticsWidget->updateStatistics();
    }
}

/**
 * @brief 用户查找
 *
 * 根据用户ID和姓名查找用户，并显示在用户表格中。
 */
void AdminWindow::onUserSearch()
{
    QString id = userIdLineEdit->text().trimmed();
    QString name = userNameLineEdit->text().trimmed();
    int roleFilter = userRoleCombo->currentIndex(); // 0=全部, 1=学生, 2=教师, 3=校外

    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        std::vector<::User *> results;
        if (id.isEmpty() && name.isEmpty())
        {
            results = admin->findAllUser();
        }
        else
        {
            results = admin->findUser(id, name);
        }

        // （角色筛选）：根据下拉框选择的角色进行过滤
        if (roleFilter > 0)
        {
            std::vector<::User *> filtered;
            for (::User *user : results)
            {
                if (user->getType() == 2)
                {
                    ::Reader *reader = dynamic_cast<::Reader *>(user);
                    if (reader && static_cast<int>(reader->getRole()) == roleFilter)
                    {
                        filtered.push_back(user);
                    }
                }
            }
            results = filtered;
        }

        displayUsers(results);
    }
}

/**
 * @brief 角色筛选下拉框改变处理
 *
 * 当角色筛选下拉框选择改变时，重新执行搜索以应用角色过滤。
 */
void AdminWindow::onUserRoleFilter()
{
    onUserSearch();
}

/**
 * @brief 显示用户
 * @param users 用户列表
 *
 * 将用户数据显示到用户表格中。
 */
void AdminWindow::displayUsers(const std::vector<::User *> &users)
{
    userTable->setRowCount(0);

    for (::User *user : users)
    {
        int row = userTable->rowCount();
        userTable->insertRow(row);

        userTable->setItem(row, 0, new QTableWidgetItem(user->getID()));
        userTable->setItem(row, 1, new QTableWidgetItem(user->getType() == 1 ? "管理员" : "读者"));

        // （显示角色）：管理员显示"-"，读者显示具体角色
        if (user->getType() == 2)
        {
            ::Reader *reader = dynamic_cast<::Reader *>(user);
            if (reader)
            {
                userTable->setItem(row, 2, new QTableWidgetItem(reader->getRoleString()));
            }
            else
            {
                userTable->setItem(row, 2, new QTableWidgetItem("-"));
            }
        }
        else
        {
            userTable->setItem(row, 2, new QTableWidgetItem("-"));
        }

        userTable->setItem(row, 3, new QTableWidgetItem(user->getName()));
        userTable->setItem(row, 4, new QTableWidgetItem(user->getPassword()));
        userTable->setItem(row, 5, new QTableWidgetItem(user->getPhone()));
        userTable->setItem(row, 6, new QTableWidgetItem(user->getEmail()));

        if (user->getType() == 2)
        {
            ::Reader *reader = dynamic_cast<::Reader *>(user);
            if (reader)
            {
                userTable->setItem(row, 7, new QTableWidgetItem(QString::number(reader->getCreditScore())));

                QDateTime banUntil = reader->getBanUntil();
                if (banUntil.isValid())
                {
                    userTable->setItem(row, 8, new QTableWidgetItem(banUntil.toString("yyyy-MM-dd HH:mm:ss")));
                }
                else
                {
                    userTable->setItem(row, 8, new QTableWidgetItem("-"));
                }
            }
            else
            {
                userTable->setItem(row, 7, new QTableWidgetItem("-"));
                userTable->setItem(row, 8, new QTableWidgetItem("-"));
            }
        }
        else
        {
            userTable->setItem(row, 7, new QTableWidgetItem("-"));
            userTable->setItem(row, 8, new QTableWidgetItem("-"));
        }
    }
}

/**
 * @brief 显示输入对话框
 * @param title 对话框标题
 * @param label 输入框标签
 * @param required 是否必填
 * @return 输入的文本和是否取消（true表示取消）
 */
QPair<QString, bool> AdminWindow::showInputDialog(const QString &title, const QString &label, bool required)
{
    QDialog dialog(this);
    dialog.setWindowTitle(title);
    dialog.setModal(true);
    dialog.setFixedSize(750, 100);

    QLabel *labelWidget = new QLabel(label, &dialog);
    QLineEdit *lineEdit = new QLineEdit(&dialog);
    lineEdit->setMinimumWidth(150);
    QPushButton *okBtn = new QPushButton("确定", &dialog);
    QPushButton *cancelBtn = new QPushButton("取消", &dialog);

    QHBoxLayout *hLayout = new QHBoxLayout();
    hLayout->addWidget(labelWidget);
    hLayout->addSpacing(15);
    hLayout->addWidget(lineEdit);
    hLayout->addSpacing(20);
    hLayout->addWidget(okBtn);
    hLayout->addSpacing(10);
    hLayout->addWidget(cancelBtn);
    dialog.setLayout(hLayout);

    QObject::connect(okBtn, &QPushButton::clicked, &dialog, &QDialog::accept);
    QObject::connect(cancelBtn, &QPushButton::clicked, &dialog, &QDialog::reject);

    while (true)
    {
        if (dialog.exec() == QDialog::Accepted)
        {
            QString text = lineEdit->text().trimmed();
            if (required && text.isEmpty())
            {
                QMessageBox msgBox(QMessageBox::Warning, "提示", "输入不能为空！", QMessageBox::NoButton, this);
                msgBox.addButton("确定", QMessageBox::AcceptRole);
                msgBox.exec();
                continue;
            }
            return qMakePair(text, false);
        }
        return qMakePair(QString(), true);
    }
}

/**
 * @brief 添加用户
 *
 * 弹出对话框输入用户信息（ID、类型、姓名、密码、电话、邮箱），添加新用户。
 */
void AdminWindow::onUserAdd()
{
    QPair<QString, bool> result = showInputDialog("增加用户", "请输入用户ID：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString id = result.first;

    DataManager *dm = DataManager::getInstance();
    if (dm->findUserById(id))
    {
        QMessageBox::warning(this, "警告", QString("用户id %1 已存在，请重试").arg(id));
        return;
    }

    result = showInputDialog("增加用户", "请输入用户类型（1-管理员/2-读者）：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString type = result.first;
    if (type != "1" && type != "2")
    {
        QMessageBox msgBox(QMessageBox::Warning, "错误", "用户类型非法！请输入1（管理员）或2（读者）", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }

    // （选择角色）：如果是读者类型，选择角色
    int role = 1; // 默认学生读者
    if (type == "2")
    {
        result = showInputDialog("增加用户", "请输入读者角色（1-学生/2-教师/3-校外人员）：", true);
        if (result.second)
        {
            QMessageBox msgBox(QMessageBox::Information, "提示", "用户添加已取消！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
            return;
        }
        bool roleOk = false;
        role = result.first.toInt(&roleOk);
        if (!roleOk || (role != 1 && role != 2 && role != 3))
        {
            QMessageBox msgBox(QMessageBox::Warning, "错误", "角色非法！请输入1（学生）、2（教师）或3（校外人员）", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
            return;
        }
    }

    result = showInputDialog("增加用户", "请输入用户姓名：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString name = result.first;

    result = showInputDialog("增加用户", "请输入用户密码：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString password = result.first;

    result = showInputDialog("增加用户", "请输入用户电话：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString phone = result.first;

    result = showInputDialog("增加用户", "请输入用户邮箱：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户添加已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString email = result.first;

    // （调用后端）：调用Admin的注册方法
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        admin->registerUser(id, type, name, password, phone, email, role);

        // （发送消息）：发送用户添加消息给管理员
        QString roleStr = (type == "1") ? "" : QString("-%1").arg(role == 2 ? "教师" : (role == 3 ? "校外人员" : "学生"));
        QString msgContent = QString("管理员%1添加了用户：%2（ID: %3, 类型: %4%5）")
                                 .arg(currentUser->getName())
                                 .arg(name)
                                 .arg(id)
                                 .arg(type == "1" ? "管理员" : "读者")
                                 .arg(roleStr);
        dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);

        // （刷新表格）：重新加载用户列表
        std::vector<::User *> users = admin->findAllUser();
        displayUsers(users);
    }

    QMessageBox msgBox(QMessageBox::Information, "成功", "用户添加成功！", QMessageBox::NoButton, this);
    msgBox.addButton("确定", QMessageBox::AcceptRole);
    msgBox.exec();
}

// （用户删除）：删除按钮点击处理
void AdminWindow::onUserDelete()
{
    // （依次输入信息）：先输入ID，再输入姓名
    QPair<QString, bool> result = showInputDialog("删除用户", "请输入要删除的用户ID：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户删除已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString id = result.first;

    result = showInputDialog("删除用户", "请输入要删除的用户姓名：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户删除已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString name = result.first;

    // （调用后端）：调用Admin的删除方法
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        // 保存原用户类型（删除前获取）
        DataManager *dm = DataManager::getInstance();
        User *userToDelete = dm->findUserById(id);
        QString userTypeName = userToDelete && userToDelete->getType() == 1 ? "管理员" : "读者";

        bool success = admin->deleteUser(id, name);

        if (success)
        {
            // （发送消息）：发送用户删除消息给管理员
            QString msgContent = QString("管理员%1删除了用户：%2（ID: %3, 类型: %4）")
                                     .arg(currentUser->getName())
                                     .arg(name)
                                     .arg(id)
                                     .arg(userTypeName);
            dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);

            // （刷新表格）：重新加载用户列表
            std::vector<::User *> users = admin->findAllUser();
            displayUsers(users);

            QMessageBox msgBox(QMessageBox::Information, "成功", "用户删除成功！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
        }
        else
        {
            QMessageBox msgBox(QMessageBox::Warning, "失败", "用户删除失败，未找到匹配的用户！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
        }
    }
}

/**
 * @brief 修改用户
 *
 * 弹出对话框输入要修改的用户ID和姓名，然后输入修改后的用户信息（ID、类型、姓名、密码、电话、邮箱）。
 */
void AdminWindow::onUserUpdate()
{
    QPair<QString, bool> result = showInputDialog("修改用户", "请输入要修改的用户ID：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString id = result.first;

    result = showInputDialog("修改用户", "请输入要修改的用户姓名：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString name = result.first;

    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        std::vector<::User *> foundUsers = admin->findUser(id, name);
        if (foundUsers.empty())
        {
            QMessageBox msgBox(QMessageBox::Warning, "失败", "用户修改失败，未找到匹配的用户！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
            return;
        }
    }

    result = showInputDialog("修改用户", "请输入修改后的用户ID：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString newId = result.first;

    result = showInputDialog("修改用户", "请输入修改后的用户类型（1-管理员/2-读者）：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString newType = result.first;
    if (newType != "1" && newType != "2")
    {
        QMessageBox msgBox(QMessageBox::Warning, "错误", "用户类型非法！请输入1（管理员）或2（读者）", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }

    // （选择角色）：如果是读者类型，选择角色
    int newRole = 1; // 默认学生读者
    if (newType == "2")
    {
        result = showInputDialog("修改用户", "请输入修改后的读者角色（1-学生/2-教师/3-校外人员）：", true);
        if (result.second)
        {
            QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
            return;
        }
        bool roleOk = false;
        newRole = result.first.toInt(&roleOk);
        if (!roleOk || (newRole != 1 && newRole != 2 && newRole != 3))
        {
            QMessageBox msgBox(QMessageBox::Warning, "错误", "角色非法！请输入1（学生）、2（教师）或3（校外人员）", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
            return;
        }
    }

    result = showInputDialog("修改用户", "请输入修改后的用户姓名：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString newName = result.first;

    result = showInputDialog("修改用户", "请输入修改后的用户密码：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString newPassword = result.first;

    result = showInputDialog("修改用户", "请输入修改后的用户电话：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString newPhone = result.first;

    result = showInputDialog("修改用户", "请输入修改后的用户邮箱：", true);
    if (result.second)
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "用户修改已取消！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }
    QString newEmail = result.first;

    // （调用后端）：调用Admin的修改方法
    admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        // 保存原用户类型
        DataManager *dm = DataManager::getInstance();
        User *oldUser = dm->findUserById(id);
        QString oldTypeName = oldUser && oldUser->getType() == 1 ? "管理员" : "读者";

        bool success = admin->updateUser(id, name, newId, newType, newName, newPassword, newPhone, newEmail, newRole);

        if (success)
        {
            // （发送消息）：发送用户修改消息给管理员
            User *updatedUser = dm->findUserById(newId);
            QString newRoleStr = (newType == "1") ? "" : QString("-%1").arg(newRole == 2 ? "教师" : (newRole == 3 ? "校外人员" : "学生"));
            QString msgContent = QString("管理员%1修改了用户信息：%2（ID: %3, 类型: %4）→ %5（ID: %6, 类型: %7%8）")
                                     .arg(currentUser->getName())
                                     .arg(name)
                                     .arg(id)
                                     .arg(oldTypeName)
                                     .arg(newName)
                                     .arg(newId)
                                     .arg(updatedUser && updatedUser->getType() == 1 ? "管理员" : "读者")
                                     .arg(newRoleStr);
            dm->addAdminMessage(currentUser, currentUser->getID(), currentUser->getName(), msgContent);

            // （刷新表格）：重新加载用户列表
            std::vector<::User *> users = admin->findAllUser();
            displayUsers(users);

            QMessageBox msgBox(QMessageBox::Information, "成功", "用户修改成功！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
        }
        else
        {
            QMessageBox msgBox(QMessageBox::Warning, "失败", "用户修改失败，未找到匹配的用户！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
        }
    }
}

// （用户清除）：清除按钮点击处理
void AdminWindow::onUserClear()
{
    // （弹出确认框）：弹出确认框警告用户是否确认清除所有用户
    QMessageBox warningBox(QMessageBox::Warning, "警告", "确定要清除所有用户信息吗？此操作不可恢复！此操作会清除所有用户数据！", QMessageBox::NoButton, this);
    QAbstractButton *yesBtn1 = warningBox.addButton("是", QMessageBox::YesRole);
    warningBox.addButton("否", QMessageBox::NoRole);
    warningBox.exec();
    if (warningBox.clickedButton() == yesBtn1)
    {
        // （再次确认）：再次弹出确认框
        QMessageBox confirmBox(QMessageBox::Question, "确认", "再次确认：是否真的要清除所有用户？", QMessageBox::NoButton, this);
        QAbstractButton *yesBtn2 = confirmBox.addButton("是", QMessageBox::YesRole);
        confirmBox.addButton("否", QMessageBox::NoRole);
        confirmBox.exec();
        if (confirmBox.clickedButton() == yesBtn2)
        {
            // （调用后端）：调用Admin的清除方法，保留当前管理员
            ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
            if (admin)
            {
                // 更新 currentUser 指针为新创建的用户对象
                currentUser = admin->clearUser(currentUser);

                // （刷新表格）：重新加载用户列表（只显示当前管理员）
                std::vector<::User *> users = admin->findAllUser();
                displayUsers(users);

                // 刷新消息表格（消息已被清空）
                if (messageTable)
                {
                    messageTable->setRowCount(0);
                }
            }

            QMessageBox msgBox(QMessageBox::Information, "成功", "已清除所有用户！", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
        }
    }
}

/**
 * @brief 切换到用户管理页面
 *
 * 加载用户数据并切换到用户管理表格视图。
 */
void AdminWindow::onUserManagement()
{
    loadUserData();
    stackedWidget->setCurrentIndex(0);
}

/**
 * @brief 切换到图书管理页面
 *
 * 加载图书数据并切换到图书管理表格视图。
 */
void AdminWindow::onBookManagement()
{
    loadBookData();
    stackedWidget->setCurrentIndex(1);
}

/**
 * @brief 切换到借阅管理页面
 *
 * 加载借阅数据并切换到借阅管理表格视图。
 */
void AdminWindow::onBorrowManagement()
{
    loadBorrowData();
    stackedWidget->setCurrentIndex(2);
}

/**
 * @brief 切换到预约管理页面
 *
 * 加载预约数据并切换到预约管理表格视图。
 */
void AdminWindow::onReservationManagement()
{
    loadReservationData();
    stackedWidget->setCurrentIndex(3);
}

/**
 * @brief 切换到统计报表页面
 *
 * 加载统计数据并切换到统计报表视图。
 */
void AdminWindow::onStatistics()
{
    loadStatisticsData();
    stackedWidget->setCurrentIndex(4);
}

/**
 * @brief 审核预约
 *
 * 对选中的预约记录进行审核，可以选择审核成功或失败。
 */
void AdminWindow::onProcessReservation()
{
    // （获取选中行）：获取当前选中的预约行
    int row = reservationTable->currentRow();
    if (row < 0)
    {
        QMessageBox msgBox(QMessageBox::Warning, "提示", "请先选择一条预约记录！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }

    QString isbn = reservationTable->item(row, 0)->text();
    QString readerId = reservationTable->item(row, 1)->text();
    QString status = reservationTable->item(row, 3)->text();

    if (status != "待审核")
    {
        QMessageBox msgBox(QMessageBox::Warning, "提示", "只能审核状态为【待审核】的预约！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }

    // （选择审核结果）：弹出选择框
    QMessageBox selectBox(QMessageBox::Question, "审核预约", QString("请选择对读者 %1 预约图书(ISBN:%2)的审核结果：").arg(readerId).arg(isbn), QMessageBox::NoButton, this);
    QAbstractButton *successBtn = selectBox.addButton("审核成功", QMessageBox::AcceptRole);
    QAbstractButton *failBtn = selectBox.addButton("审核失败", QMessageBox::AcceptRole);
    QAbstractButton *cancelBtn = selectBox.addButton("取消", QMessageBox::RejectRole);
    selectBox.exec();

    // 点击取消按钮或右上角×号都直接返回，不做任何操作
    if (selectBox.clickedButton() == cancelBtn || selectBox.clickedButton() == nullptr)
    {
        return;
    }

    bool isSuccess = (selectBox.clickedButton() == successBtn);

    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (admin)
    {
        bool result = admin->approveReservation(isbn, readerId, isSuccess);

        loadReservationData();

        if (result)
        {
            QString msg = isSuccess ? "审核成功！已通知相关读者。" : "审核失败！已通知相关读者。";
            QMessageBox msgBox(QMessageBox::Information, "成功", msg, QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
        }
        else
        {
            QMessageBox msgBox(QMessageBox::Warning, "失败", "审核失败！可能该预约已不是待审核状态。", QMessageBox::NoButton, this);
            msgBox.addButton("确定", QMessageBox::AcceptRole);
            msgBox.exec();
        }
    }
}

/**
 * @brief 查询预约
 *
 * 根据ISBN、读者ID、预约时间和状态等条件筛选预约记录，并显示在预约表格中。
 */
void AdminWindow::onSearchReservation()
{
    DataManager *dm = DataManager::getInstance();
    QString isbnFilter = reservationISBNLineEdit->text().trimmed();
    QString readerIdFilter = reservationReaderIdLineEdit->text().trimmed();
    QString timeFilter = reservationTimeLineEdit->text().trimmed();
    QString statusFilter = reservationStatusCombo->currentText();

    std::vector<Reservation> allReservations = dm->getReservations();
    std::vector<Reservation> filteredReservations;

    for (const auto &reservation : allReservations)
    {
        bool match = true;

        if (!isbnFilter.isEmpty())
        {
            if (!reservation.getISBN().contains(isbnFilter))
                match = false;
        }

        if (!readerIdFilter.isEmpty())
        {
            if (!reservation.getReaderID().contains(readerIdFilter))
                match = false;
        }

        if (!timeFilter.isEmpty())
        {
            if (!reservation.getReserveTime().toString("yyyy-MM-dd HH:mm:ss").contains(timeFilter))
                match = false;
        }

        if (!statusFilter.isEmpty())
        {
            if (reservation.getStatusString() != statusFilter)
                match = false;
        }

        if (match)
            filteredReservations.push_back(reservation);
    }

    reservationTable->setRowCount(0);
    for (const auto &reservation : filteredReservations)
    {
        int row = reservationTable->rowCount();
        reservationTable->insertRow(row);

        reservationTable->setItem(row, 0, new QTableWidgetItem(reservation.getISBN()));
        reservationTable->setItem(row, 1, new QTableWidgetItem(reservation.getReaderID()));
        reservationTable->setItem(row, 2, new QTableWidgetItem(reservation.getReserveTime().toString("yyyy-MM-dd HH:mm:ss")));
        reservationTable->setItem(row, 3, new QTableWidgetItem(reservation.getStatusString()));
    }
}

/**
 * @brief 设置消息管理页面
 *
 * 创建消息管理界面，包括操作按钮、查找输入框和消息列表。
 */
void AdminWindow::setupMessageWidget()
{
    messageWidget = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(messageWidget);

    // 操作按钮和查找输入框布局（同一行）
    QHBoxLayout *topLayout = new QHBoxLayout();

    // 操作按钮
    QPushButton *deleteMessageBtn = new QPushButton("删除消息", this);
    QPushButton *clearAllMessagesBtn = new QPushButton("清除所有消息", this);
    QPushButton *markAllReadBtn = new QPushButton("全部设为已读", this);

    topLayout->addWidget(deleteMessageBtn);
    topLayout->addWidget(clearAllMessagesBtn);
    topLayout->addWidget(markAllReadBtn);

    // 添加分隔
    QFrame *separator = new QFrame(this);
    separator->setFrameShape(QFrame::VLine);
    separator->setFrameShadow(QFrame::Sunken);
    topLayout->addWidget(separator);

    // 消息查找输入框（每列一个）
    messageReaderIdEdit = new QLineEdit(this);
    messageReaderIdEdit->setPlaceholderText("用户ID");
    messageReaderIdEdit->setFixedWidth(80);

    messageReaderNameEdit = new QLineEdit(this);
    messageReaderNameEdit->setPlaceholderText("用户名");
    messageReaderNameEdit->setFixedWidth(80);

    messageTimeEdit = new QLineEdit(this);
    messageTimeEdit->setPlaceholderText("消息时间");
    messageTimeEdit->setFixedWidth(130);

    messageContentEdit = new QLineEdit(this);
    messageContentEdit->setPlaceholderText("消息内容");
    messageContentEdit->setFixedWidth(200);

    messageStatusCombo = new QComboBox(this);
    messageStatusCombo->addItem("");
    messageStatusCombo->addItem("已读");
    messageStatusCombo->addItem("未读");
    messageStatusCombo->setFixedWidth(80);

    QPushButton *searchMessageBtn = new QPushButton("查找消息", this);

    topLayout->addWidget(messageReaderIdEdit);
    topLayout->addWidget(messageReaderNameEdit);
    topLayout->addWidget(messageTimeEdit);
    topLayout->addWidget(messageContentEdit);
    topLayout->addWidget(messageStatusCombo);
    topLayout->addWidget(searchMessageBtn);
    topLayout->addStretch();

    connect(deleteMessageBtn, &QPushButton::clicked, this, &AdminWindow::onDeleteMessage);
    connect(clearAllMessagesBtn, &QPushButton::clicked, this, &AdminWindow::onClearAllMessages);
    connect(markAllReadBtn, &QPushButton::clicked, this, &AdminWindow::onMarkAllRead);
    connect(searchMessageBtn, &QPushButton::clicked, this, &AdminWindow::onSearchMessage);

    mainLayout->addLayout(topLayout);

    messageTable = new QTableWidget(this);
    messageTable->setColumnCount(5);
    messageTable->setHorizontalHeaderLabels(QStringList() << "用户ID" << "用户名" << "消息时间" << "消息内容" << "消息状态");
    messageTable->horizontalHeader()->setStretchLastSection(true);
    messageTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    messageTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    messageTable->setColumnWidth(0, 80);
    messageTable->setColumnWidth(1, 80);
    messageTable->setColumnWidth(2, 130);
    messageTable->setColumnWidth(3, 400);
    messageTable->setColumnWidth(4, 80);

    mainLayout->addWidget(messageTable);
    messageWidget->setLayout(mainLayout);
}

/**
 * @brief 显示消息列表
 * @param messages 消息列表
 *
 * 将消息列表显示到消息表格中。
 */
void AdminWindow::displayMessages(const std::vector<Message> &messages)
{
    messageTable->setRowCount(messages.size());
    for (size_t i = 0; i < messages.size(); ++i)
    {
        const Message &msg = messages[i];
        std::vector<QString> fields = msg.getAdminDisplayFields();

        for (int j = 0; j < fields.size() && j < 5; ++j)
        {
            messageTable->setItem(i, j, new QTableWidgetItem(fields[j]));
        }
    }
}

/**
 * @brief 切换到消息管理页面
 *
 * 切换到消息管理视图并加载当前管理员的消息列表。
 */
void AdminWindow::onMessage()
{
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (!admin)
    {
        return;
    }

    stackedWidget->setCurrentWidget(messageWidget);
    displayMessages(admin->getMessages());
}

/**
 * @brief 退出登录
 *
 * 弹出确认对话框，确认后退出登录并发出logout信号。
 */
void AdminWindow::onLogout()
{
    QMessageBox confirmBox(QMessageBox::Question, "确认退出", "确定要退出登录吗？", QMessageBox::NoButton, this);
    QAbstractButton *yesBtn = confirmBox.addButton("是", QMessageBox::YesRole);
    confirmBox.addButton("否", QMessageBox::NoRole);
    confirmBox.exec();

    if (confirmBox.clickedButton() == yesBtn)
    {
        QMessageBox::information(this, "成功", "退出登录成功！");
        emit logout();
    }
}

/**
 * @brief 删除选中消息
 *
 * 删除当前选中的消息。
 */
void AdminWindow::onDeleteMessage()
{
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (!admin)
    {
        return;
    }

    int currentRow = messageTable->currentRow();
    if (currentRow < 0)
    {
        QMessageBox msgBox(QMessageBox::Warning, "提示", "请先选择要删除的消息！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
        return;
    }

    QMessageBox confirmBox(QMessageBox::Question, "确认删除", "确定要删除选中的消息吗？", QMessageBox::NoButton, this);
    QAbstractButton *yesBtn = confirmBox.addButton("是", QMessageBox::YesRole);
    confirmBox.addButton("否", QMessageBox::NoRole);
    confirmBox.exec();

    if (confirmBox.clickedButton() == yesBtn)
    {
        admin->deleteMessage(currentRow);
        DataManager::getInstance()->writeMessage();
        displayMessages(admin->getMessages());

        QMessageBox msgBox(QMessageBox::Information, "成功", "消息删除成功！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
    }
}

/**
 * @brief 清除所有消息
 *
 * 清除当前管理员的所有消息。
 */
void AdminWindow::onClearAllMessages()
{
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (!admin)
    {
        return;
    }

    QMessageBox confirmBox(QMessageBox::Question, "确认清除", "确定要清除所有消息吗？此操作不可恢复！", QMessageBox::NoButton, this);
    QAbstractButton *yesBtn = confirmBox.addButton("是", QMessageBox::YesRole);
    confirmBox.addButton("否", QMessageBox::NoRole);
    confirmBox.exec();

    if (confirmBox.clickedButton() == yesBtn)
    {
        admin->clearMessages();
        DataManager::getInstance()->writeMessage();
        displayMessages(std::vector<Message>());

        QMessageBox msgBox(QMessageBox::Information, "成功", "所有消息已清除！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
    }
}

/**
 * @brief 全部设为已读
 *
 * 将当前管理员的所有未读消息标记为已读。
 */
void AdminWindow::onMarkAllRead()
{
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (!admin)
    {
        return;
    }

    std::vector<Message> &messages = admin->getMessages();
    bool hasUnread = false;

    for (auto &msg : messages)
    {
        if (msg.getStatus() == MessageStatus::UNREAD)
        {
            msg.setStatus(MessageStatus::READ);
            hasUnread = true;
        }
    }

    if (hasUnread)
    {
        DataManager::getInstance()->writeMessage();
        displayMessages(messages);

        QMessageBox msgBox(QMessageBox::Information, "成功", "所有消息已设为已读！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
    }
    else
    {
        QMessageBox msgBox(QMessageBox::Information, "提示", "没有未读消息！", QMessageBox::NoButton, this);
        msgBox.addButton("确定", QMessageBox::AcceptRole);
        msgBox.exec();
    }
}

/**
 * @brief 查找消息
 *
 * 根据读者ID、读者名、消息时间、消息内容和消息状态等条件筛选消息。
 */
void AdminWindow::onSearchMessage()
{
    ::Admin *admin = dynamic_cast<::Admin *>(currentUser);
    if (!admin)
    {
        return;
    }

    QString readerId = messageReaderIdEdit->text().trimmed();
    QString readerName = messageReaderNameEdit->text().trimmed();
    QString time = messageTimeEdit->text().trimmed();
    QString content = messageContentEdit->text().trimmed();
    QString status = messageStatusCombo->currentText().trimmed();

    std::vector<Message> allMessages = admin->getMessages();
    std::vector<Message> filteredMessages;

    if (readerId.isEmpty() && readerName.isEmpty() && time.isEmpty() && content.isEmpty() && status.isEmpty())
    {
        displayMessages(allMessages);
        return;
    }

    for (const auto &msg : allMessages)
    {
        std::vector<QString> fields = msg.getAdminDisplayFields();
        bool match = true;

        if (!readerId.isEmpty() && !fields[0].contains(readerId, Qt::CaseInsensitive))
        {
            match = false;
        }
        if (match && !readerName.isEmpty() && !fields[1].contains(readerName, Qt::CaseInsensitive))
        {
            match = false;
        }
        if (match && !time.isEmpty() && !fields[2].contains(time, Qt::CaseInsensitive))
        {
            match = false;
        }
        // 消息内容匹配
        if (match && !content.isEmpty() && !fields[3].contains(content, Qt::CaseInsensitive))
        {
            match = false;
        }
        // 消息状态匹配
        if (match && !status.isEmpty() && !fields[4].contains(status, Qt::CaseInsensitive))
        {
            match = false;
        }

        if (match)
        {
            filteredMessages.push_back(msg);
        }
    }

    displayMessages(filteredMessages);
}