readerwindow.cpp

/**
 * @file readerwindow.cpp
 * @brief 读者窗口类实现
 *
 * 实现ReaderWindow类的所有成员函数，包括图书查询、借阅管理、
 * 预约管理、消息管理和个人信息等功能。
 */

#include "readerwindow.h"
#include "Reader.h"
#include "StudentReader.h"
#include "TeacherReader.h"
#include "ExternalReader.h"
#include "DataManager.h"
#include <QIcon>
#include <QDialog>
#include <QLabel>
#include <QDialogButtonBox>
#include <QVBoxLayout>
#include <QDateTime>
#include <QInputDialog>

/**
 * @brief 构造函数
 * @param user 当前登录的用户对象
 * @param parent 父窗口
 *
 * 初始化读者窗口，设置窗口属性、工具栏和各个功能页面。
 */
ReaderWindow::ReaderWindow(User *user, QWidget *parent)
    : QMainWindow(parent)
{
    currentUser = user;
    resize(800, 800);
    setWindowIcon(QIcon(":/image/book.png"));

    // 禁用关闭按钮
    setWindowFlags(windowFlags() & ~Qt::WindowCloseButtonHint);

    if (user)
    {
        QString title = QString("%1 - %2").arg(user->typeToIdentity()).arg(user->getName());
        setWindowTitle(title);
    }

    setupCentralWidget();
}

/**
 * @brief 析构函数
 */
ReaderWindow::~ReaderWindow()
{
}

/**
 * @brief 设置中心窗口
 *
 * 初始化工具栏和堆叠窗口，创建各个功能页面并添加到堆叠窗口中。
 */
void ReaderWindow::setupCentralWidget()
{
    stackedWidget = new QStackedWidget(this);
    setCentralWidget(stackedWidget);

    toolbar = new QToolBar("工具栏", this);
    toolbar->setMovable(false);
    toolbar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
    addToolBar(Qt::LeftToolBarArea, toolbar);

    // 创建工具栏动作
    QAction *bookSearchAction = new QAction(QIcon(":/image/book2.png"), "图书查询", this);
    QAction *myBorrowAction = new QAction(QIcon(":/image/readerborrow.png"), "我的借阅", this);
    QAction *myReservationAction = new QAction(QIcon(":/image/readerReservation.png"), "我的预约", this);
    QAction *messageAction = new QAction(QIcon(":/image/message.png"), "消息管理", this);
    QAction *infoAction = new QAction(QIcon(":/image/user.png"), "个人信息", this);
    QAction *logoutAction = new QAction(QIcon(":/image/logout.png"), "退出登录", this);

    // 添加动作到工具栏
    toolbar->addAction(bookSearchAction);
    toolbar->addAction(myBorrowAction);
    toolbar->addAction(myReservationAction);
    toolbar->addAction(messageAction);
    toolbar->addAction(infoAction);
    toolbar->addAction(logoutAction);

    // 连接信号槽
    connect(bookSearchAction, &QAction::triggered, this, &ReaderWindow::switchToBookSearch);
    connect(myBorrowAction, &QAction::triggered, this, &ReaderWindow::switchToMyBorrow);
    connect(myReservationAction, &QAction::triggered, this, &ReaderWindow::switchToMyReservation);
    connect(messageAction, &QAction::triggered, this, &ReaderWindow::onCheckMessages);
    connect(infoAction, &QAction::triggered, this, &ReaderWindow::switchToInfo);
    connect(logoutAction, &QAction::triggered, this, &ReaderWindow::onLogout);

    // 设置各个页面
    setupBookSearchWidget();
    setupMyBorrowWidget();
    setupMyReservationWidget();
    setupMessageWidget();
    setupInfoWidget();

    // 添加页面到堆叠窗口
    stackedWidget->addWidget(bookSearchWidget);
    stackedWidget->addWidget(myBorrowWidget);
    stackedWidget->addWidget(myReservationWidget);
    stackedWidget->addWidget(messageWidget);
    stackedWidget->addWidget(infoWidget);

    // 默认显示图书查询页面
    stackedWidget->setCurrentIndex(0);
}

/**
 * @brief 设置图书查询页面
 *
 * 创建图书查询界面，包括搜索输入框、操作按钮和图书表格。
 */
void ReaderWindow::setupBookSearchWidget()
{
    bookSearchWidget = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(bookSearchWidget);

    // 搜索区域
    QHBoxLayout *searchLayout = new QHBoxLayout();

    // 操作按钮（预约、借书）
    bookReserveBtn = new QPushButton("预约", this);
    borrowBtn = new QPushButton("借书", this);

    searchLayout->addWidget(bookReserveBtn);
    searchLayout->addWidget(borrowBtn);

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

    // 输入框（无标签，使用placeholder提示）
    bookISBNLineEdit = new QLineEdit(this);
    bookISBNLineEdit->setPlaceholderText("ISBN");
    bookISBNLineEdit->setFixedWidth(150);

    bookTitleLineEdit = new QLineEdit(this);
    bookTitleLineEdit->setPlaceholderText("书名");
    bookTitleLineEdit->setFixedWidth(150);

    bookAuthorLineEdit = new QLineEdit(this);
    bookAuthorLineEdit->setPlaceholderText("作者");
    bookAuthorLineEdit->setFixedWidth(120);

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

    searchLayout->addWidget(bookISBNLineEdit);
    searchLayout->addWidget(bookTitleLineEdit);
    searchLayout->addWidget(bookAuthorLineEdit);
    searchLayout->addWidget(bookCategoryLineEdit);

    // 查找按钮紧跟在分类输入框后面
    bookSearchBtn = new QPushButton("查找", this);
    searchLayout->addWidget(bookSearchBtn);

    // 添加伸缩空间到末尾，保持控件紧凑
    searchLayout->addStretch();

    mainLayout->addLayout(searchLayout);

    // 图书表格
    bookSearchTable = new QTableWidget(this);
    bookSearchTable->setColumnCount(10);
    QStringList headers = {"ISBN", "书名", "作者", "分类", "库存", "入库时间", "借阅次数", "当前借出", "状态", "预约人数"};
    bookSearchTable->setHorizontalHeaderLabels(headers);
    bookSearchTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    bookSearchTable->setSelectionBehavior(QTableWidget::SelectRows);
    mainLayout->addWidget(bookSearchTable);

    // 连接信号槽
    connect(bookSearchBtn, &QPushButton::clicked, this, &ReaderWindow::onBookSearch);
    connect(bookReserveBtn, &QPushButton::clicked, this, &ReaderWindow::onBookReserve);
    connect(borrowBtn, &QPushButton::clicked, this, &ReaderWindow::onBorrowBook);

    // 初始化显示所有图书
    onBookSearch();
}

/**
 * @brief 设置我的借阅页面
 *
 * 创建借阅管理界面，包括操作按钮（还书、续借、支付罚款）、
 * 查询输入框和借阅记录表格。
 */
void ReaderWindow::setupMyBorrowWidget()
{
    myBorrowWidget = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(myBorrowWidget);

    // 顶部工具栏区域
    QHBoxLayout *topLayout = new QHBoxLayout();

    // 操作按钮
    returnBtn = new QPushButton("还书", this);
    renewBtn = new QPushButton("续借", this);
    payFineBtn = new QPushButton("支付所有罚款", this);

    topLayout->addWidget(returnBtn);
    topLayout->addWidget(renewBtn);
    topLayout->addWidget(payFineBtn);

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

    // 查询输入框
    borrowISBNEdit = new QLineEdit(this);
    borrowISBNEdit->setPlaceholderText("ISBN");
    borrowISBNEdit->setFixedWidth(120);

    borrowTitleEdit = new QLineEdit(this);
    borrowTitleEdit->setPlaceholderText("书名");
    borrowTitleEdit->setFixedWidth(150);

    borrowTimeEdit = new QLineEdit(this);
    borrowTimeEdit->setPlaceholderText("借阅时间");
    borrowTimeEdit->setFixedWidth(120);

    borrowDueTimeEdit = new QLineEdit(this);
    borrowDueTimeEdit->setPlaceholderText("应还时间");
    borrowDueTimeEdit->setFixedWidth(120);

    borrowReturnTimeEdit = new QLineEdit(this);
    borrowReturnTimeEdit->setPlaceholderText("归还时间");
    borrowReturnTimeEdit->setFixedWidth(120);

    borrowStatusEdit = new QLineEdit(this);
    borrowStatusEdit->setPlaceholderText("状态");
    borrowStatusEdit->setFixedWidth(80);

    borrowRenewCombo = new QComboBox(this);
    borrowRenewCombo->addItem("");
    borrowRenewCombo->addItem("无申请");
    borrowRenewCombo->addItem("待审核");
    borrowRenewCombo->addItem("已通过");
    borrowRenewCombo->addItem("已拒绝");
    borrowRenewCombo->setFixedWidth(80);

    borrowFineCombo = new QComboBox(this);
    borrowFineCombo->addItem("");
    borrowFineCombo->addItem("未支付");
    borrowFineCombo->addItem("已支付");
    borrowFineCombo->setFixedWidth(80);

    QPushButton *searchBorrowBtn = new QPushButton("查找", this);

    topLayout->addWidget(borrowISBNEdit);
    topLayout->addWidget(borrowTitleEdit);
    topLayout->addWidget(borrowTimeEdit);
    topLayout->addWidget(borrowDueTimeEdit);
    topLayout->addWidget(borrowReturnTimeEdit);
    topLayout->addWidget(borrowStatusEdit);
    topLayout->addWidget(borrowRenewCombo);
    topLayout->addWidget(borrowFineCombo);
    topLayout->addWidget(searchBorrowBtn);
    topLayout->addStretch();

    mainLayout->addLayout(topLayout);

    // 借阅记录表格
    myBorrowTable = new QTableWidget(this);
    myBorrowTable->setColumnCount(9);
    QStringList headers = {"ISBN", "书名", "借阅时间", "应还时间", "状态", "续借状态", "续借次数", "罚款金额", "已支付罚款"};
    myBorrowTable->setHorizontalHeaderLabels(headers);
    myBorrowTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    myBorrowTable->setSelectionBehavior(QTableWidget::SelectRows);
    mainLayout->addWidget(myBorrowTable);

    // 连接信号槽
    connect(returnBtn, &QPushButton::clicked, this, &ReaderWindow::onReturnBook);
    connect(renewBtn, &QPushButton::clicked, this, &ReaderWindow::onRenewBook);
    connect(payFineBtn, &QPushButton::clicked, this, &ReaderWindow::onPayAllFines);
    connect(searchBorrowBtn, &QPushButton::clicked, this, &ReaderWindow::onSearchBorrow);

    // 初始化显示借阅记录
    displayMyBorrowRecords();
}

/**
 * @brief 设置我的预约页面
 *
 * 创建预约管理界面，包括取消预约按钮、查询输入框和预约记录表格。
 */
void ReaderWindow::setupMyReservationWidget()
{
    myReservationWidget = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(myReservationWidget);

    // 顶部按钮区域
    QHBoxLayout *topLayout = new QHBoxLayout(this);

    QPushButton *cancelReservationBtn = new QPushButton("取消预约", this);

    topLayout->addWidget(cancelReservationBtn);

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

    // 预约查找输入框
    reservationTimeEdit = new QLineEdit(this);
    reservationTimeEdit->setPlaceholderText("预约时间");
    reservationTimeEdit->setFixedWidth(150);

    reservationISBNEdit = new QLineEdit(this);
    reservationISBNEdit->setPlaceholderText("ISBN");
    reservationISBNEdit->setFixedWidth(150);

    reservationTitleEdit = new QLineEdit(this);
    reservationTitleEdit->setPlaceholderText("书名");
    reservationTitleEdit->setFixedWidth(200);

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

    QPushButton *searchReservationBtn = new QPushButton("查找预约", this);

    topLayout->addWidget(reservationISBNEdit);
    topLayout->addWidget(reservationTitleEdit);
    topLayout->addWidget(reservationTimeEdit);
    topLayout->addWidget(reservationStatusCombo);
    topLayout->addWidget(searchReservationBtn);
    topLayout->addStretch();

    // 连接信号槽
    connect(cancelReservationBtn, &QPushButton::clicked, this, &ReaderWindow::onCancelReservation);
    connect(searchReservationBtn, &QPushButton::clicked, this, &ReaderWindow::onSearchReservation);

    mainLayout->addLayout(topLayout);

    // 预约记录表格
    myReservationTable = new QTableWidget(this);
    myReservationTable->setColumnCount(4);
    QStringList headers = {"ISBN", "书名", "预约时间", "状态"};
    myReservationTable->setHorizontalHeaderLabels(headers);
    myReservationTable->horizontalHeader()->setStretchLastSection(true);
    myReservationTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    myReservationTable->setSelectionBehavior(QTableWidget::SelectRows);
    myReservationTable->setColumnWidth(0, 120);
    myReservationTable->setColumnWidth(1, 250);
    myReservationTable->setColumnWidth(2, 150);
    myReservationTable->setColumnWidth(3, 80);

    mainLayout->addWidget(myReservationTable);

    // 初始化显示预约记录
    displayMyReservations();
}

/**
 * @brief 根据输入条件查询图书
 *
 * 从输入框获取ISBN、书名、作者、分类等条件，
 * 调用读者的findBook方法进行查询，并显示结果。
 */
void ReaderWindow::onBookSearch()
{
    QString isbn = bookISBNLineEdit->text();
    QString title = bookTitleLineEdit->text();
    QString author = bookAuthorLineEdit->text();
    QString category = bookCategoryLineEdit->text();

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

/**
 * @brief 显示图书列表
 * @param books 要显示的图书列表
 *
 * 将图书列表显示在图书查询表格中，包括ISBN、书名、作者、
 * 分类、库存、入库时间、借阅次数、当前借出、状态和预约人数。
 */
void ReaderWindow::displayBooks(const std::vector<const Book *> &books)
{
    bookSearchTable->setRowCount(0);
    for (const auto *book : books)
    {
        int row = bookSearchTable->rowCount();
        bookSearchTable->insertRow(row);
        bookSearchTable->setItem(row, 0, new QTableWidgetItem(book->getISBN()));
        bookSearchTable->setItem(row, 1, new QTableWidgetItem(book->getTitle()));
        bookSearchTable->setItem(row, 2, new QTableWidgetItem(book->getAuthor()));
        bookSearchTable->setItem(row, 3, new QTableWidgetItem(book->getCategory()));
        bookSearchTable->setItem(row, 4, new QTableWidgetItem(QString::number(book->getStock())));
        bookSearchTable->setItem(row, 5, new QTableWidgetItem(book->getInStockTime().toString("yyyy-MM-dd HH:mm:ss")));
        bookSearchTable->setItem(row, 6, new QTableWidgetItem(QString::number(book->getBorrowCount())));
        bookSearchTable->setItem(row, 7, new QTableWidgetItem(QString::number(book->getCurrentBorrowed())));
        bookSearchTable->setItem(row, 8, new QTableWidgetItem(book->getStatus()));
        bookSearchTable->setItem(row, 9, new QTableWidgetItem(QString::number(book->getReservationCount())));
    }
}

/**
 * @brief 显示我的借阅记录
 *
 * 获取当前读者的所有借阅记录，显示在借阅记录表格中，
 * 包括ISBN、书名、借阅时间、应还时间、归还时间、状态、
 * 续借状态、罚款金额、已支付罚款和罚款状态。
 */
void ReaderWindow::displayMyBorrowRecords()
{
    myBorrowTable->setRowCount(0);
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (reader)
    {
        std::vector<BorrowRecord> records = reader->viewMyBorrowRecords();
        for (const auto &record : records)
        {
            int row = myBorrowTable->rowCount();
            myBorrowTable->insertRow(row);
            myBorrowTable->setItem(row, 0, new QTableWidgetItem(record.getISBN()));

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

            myBorrowTable->setItem(row, 2, new QTableWidgetItem(record.getBorrowTime().toString("yyyy-MM-dd HH:mm:ss")));
            myBorrowTable->setItem(row, 3, new QTableWidgetItem(record.getDueTime().toString("yyyy-MM-dd HH:mm:ss")));

            QString status = "借阅中";
            if (record.calculateOverdueDays() > 0)
            {
                status = QString("逾期(%1天)").arg(record.calculateOverdueDays());
            }
            myBorrowTable->setItem(row, 4, 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 = "未知";
            }
            myBorrowTable->setItem(row, 5, new QTableWidgetItem(renewStatus));

            // 续借次数
            myBorrowTable->setItem(row, 6, new QTableWidgetItem(QString::number(record.getRenewCount())));

            // 罚款信息（使用读者策略的罚款标准）
            double finePerDay = reader->getFinePerDay();
            double fineAmount = record.calculateFine(finePerDay);
            double paidFine = record.getPaidFine();
            myBorrowTable->setItem(row, 7, new QTableWidgetItem(QString::number(fineAmount, 'f', 2) + "元"));
            myBorrowTable->setItem(row, 8, new QTableWidgetItem(QString::number(paidFine, 'f', 2) + "元"));
        }
    }
}

/**
 * @brief 显示我的预约记录
 *
 * 获取当前读者的所有预约记录，显示在预约记录表格中，
 * 包括ISBN、书名、预约时间和状态。
 */
void ReaderWindow::displayMyReservations()
{
    myReservationTable->setRowCount(0);
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (reader)
    {
        std::vector<Reservation> reservations = reader->viewMyReservations();
        for (const auto &reservation : reservations)
        {
            int row = myReservationTable->rowCount();
            myReservationTable->insertRow(row);
            myReservationTable->setItem(row, 0, new QTableWidgetItem(reservation.getISBN()));

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

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

/**
 * @brief 预约图书
 *
 * 弹出对话框输入ISBN，调用读者的reserveBook方法进行预约，
 * 并根据返回结果显示相应的提示信息。
 */
void ReaderWindow::onBookReserve()
{
    QPair<QString, bool> result = showInputDialog("预约图书", "请输入要预约的图书ISBN：");
    if (result.second)
        return;

    QString isbn = result.first;
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (reader)
    {
        Reader::ReserveResult result = reader->reserveBook(isbn);
        if (result == Reader::ReserveResult::SUCCESS)
        {
            QMessageBox::information(this, "成功", "预约成功！等待管理员审核。");
            onBookSearch();
            displayMyReservations();
        }
        else if (result == Reader::ReserveResult::BOOK_NOT_FOUND)
        {
            QMessageBox::warning(this, "失败", "预约失败！图书不存在。");
        }
        else if (result == Reader::ReserveResult::ALREADY_EXISTS)
        {
            QMessageBox::warning(this, "失败", "预约失败！您已预约或已借阅该图书。");
        }
        else if (result == Reader::ReserveResult::EXCEED_LIMIT)
        {
            QMessageBox::warning(this, "失败", "预约失败！该图书预约人数已达上限（预约量不超过库存的2倍）。");
        }
        else if (result == Reader::ReserveResult::LOW_CREDIT)
        {
            QMessageBox::warning(this, "失败", "您因信用分下降被限制操作，暂时无法预约。");
        }
        else if (result == Reader::ReserveResult::DEPOSIT_REQUIRED)
        {
            QMessageBox::warning(this, "失败", "预约失败！您尚未缴纳押金，请先在个人信息页面缴纳押金。");
        }
    }
}

/**
 * @brief 取消预约
 *
 * 弹出对话框输入ISBN，调用读者的cancelReservation方法取消预约，
 * 并根据返回结果显示相应的提示信息。
 */
void ReaderWindow::onCancelReservation()
{
    QPair<QString, bool> result = showInputDialog("取消预约", "请输入要取消预约的图书ISBN：");
    if (result.second)
        return;

    QString isbn = result.first;
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (reader)
    {
        bool success = reader->cancelReservation(isbn);
        if (success)
        {
            QMessageBox::information(this, "成功", "取消预约成功！");
            displayMyReservations();
            onBookSearch();
        }
        else
        {
            QMessageBox::warning(this, "失败", "取消预约失败！预约记录不存在或已审核。");
        }
    }
}

/**
 * @brief 查找预约
 *
 * 根据预约时间、ISBN、书名和状态等条件筛选预约记录，
 * 并显示在预约记录表格中。
 */
void ReaderWindow::onSearchReservation()
{
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (!reader)
        return;

    QString timeFilter = reservationTimeEdit->text().trimmed();
    QString isbnFilter = reservationISBNEdit->text().trimmed();
    QString titleFilter = reservationTitleEdit->text().trimmed();
    QString statusFilter = reservationStatusCombo->currentText();

    std::vector<Reservation> allReservations = reader->viewMyReservations();
    std::vector<Reservation> filteredReservations;

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

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

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

        if (!titleFilter.isEmpty())
        {
            DataManager *dm = DataManager::getInstance();
            Book *book = dm->findBookByISBN(reservation.getISBN());
            if (!book || !book->getTitle().contains(titleFilter))
                match = false;
        }

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

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

    myReservationTable->setRowCount(0);
    for (const auto &reservation : filteredReservations)
    {
        int row = myReservationTable->rowCount();
        myReservationTable->insertRow(row);
        myReservationTable->setItem(row, 0, new QTableWidgetItem(reservation.getISBN()));

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

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

    myReservationTable->setColumnWidth(0, 120);
    myReservationTable->setColumnWidth(1, 250);
    myReservationTable->setColumnWidth(2, 150);
    myReservationTable->setColumnWidth(3, 80);
}

/**
 * @brief 借书
 *
 * 弹出对话框输入ISBN，调用读者的borrowBook方法进行借阅，
 * 并根据返回结果显示相应的提示信息。
 */
void ReaderWindow::onBorrowBook()
{
    QPair<QString, bool> result = showInputDialog("借书", "请输入要借阅的图书ISBN：");
    if (result.second)
        return;

    QString isbn = result.first;
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (reader)
    {
        Reader::BorrowResult borrowResult = reader->borrowBook(isbn);
        switch (borrowResult)
        {
        case Reader::BorrowResult::SUCCESS:
            QMessageBox::information(this, "成功", "借书成功！");
            onBookSearch();
            displayMyBorrowRecords();
            break;
        case Reader::BorrowResult::BOOK_NOT_FOUND:
            QMessageBox::warning(this, "失败", "借书失败！图书不存在。");
            break;
        case Reader::BorrowResult::NO_STOCK:
            QMessageBox::warning(this, "失败", "借书失败！图书无库存。");
            break;
        case Reader::BorrowResult::HAS_OVERDUE:
            QMessageBox::warning(this, "失败", "借书失败！您有逾期未还图书，请先归还。");
            break;
        case Reader::BorrowResult::EXCEED_LIMIT:
        {
            // （显示策略限制）：从借阅策略获取最大借阅数量
            int maxBooks = reader->getMaxBooks();
            QMessageBox::warning(this, "失败", QString("借书失败！您已达到最大借阅数量（%1本）。").arg(maxBooks));
            break;
        }
        case Reader::BorrowResult::ALREADY_BORROWED:
            QMessageBox::warning(this, "失败", "借书失败！您已借阅该图书且尚未归还，不能重复借阅。");
            break;
        case Reader::BorrowResult::NO_VALID_RESERVATION:
            QMessageBox::warning(this, "失败", "借书失败！您未预约成功该图书，请先预约并等待管理员审核。");
            break;
        case Reader::BorrowResult::LOW_CREDIT:
            QMessageBox::warning(this, "失败", "您因信用分下降被限制操作，暂时无法借书。");
            break;
        case Reader::BorrowResult::DEPOSIT_REQUIRED:
            QMessageBox::warning(this, "失败", "借书失败！您尚未缴纳押金，请先在个人信息页面缴纳押金。");
            break;
        }
    }
}

/**
 * @brief 还书
 *
 * 弹出对话框输入ISBN，调用读者的returnBook方法进行还书，
 * 并根据返回结果显示相应的提示信息。
 */
void ReaderWindow::onReturnBook()
{
    QPair<QString, bool> result = showInputDialog("还书", "请输入要归还的图书ISBN：");
    if (result.second)
        return;

    QString isbn = result.first;
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (reader)
    {
        Reader::ReturnResult returnResult = reader->returnBook(isbn);
        switch (returnResult)
        {
        case Reader::ReturnResult::SUCCESS:
            QMessageBox::information(this, "成功", "还书成功！");
            displayMyBorrowRecords();
            onBookSearch();
            break;
        case Reader::ReturnResult::NOT_FOUND:
            QMessageBox::warning(this, "失败", "还书失败！借阅记录不存在。");
            break;
        case Reader::ReturnResult::HAS_UNPAID_FINE:
            QMessageBox::warning(this, "失败", "还书失败！该图书存在未支付罚款，请先支付罚款后再还书。");
            break;
        }
    }
}

/**
 * @brief 续借
 *
 * 弹出对话框输入ISBN，调用读者的renewBook方法申请续借，
 * 并根据返回结果显示相应的提示信息。
 */
void ReaderWindow::onRenewBook()
{
    QPair<QString, bool> result = showInputDialog("续借", "请输入要续借的图书ISBN：");
    if (result.second)
        return;

    QString isbn = result.first;
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (reader)
    {
        Reader::RenewResult renewResult = reader->renewBook(isbn);
        switch (renewResult)
        {
        case Reader::RenewResult::SUCCESS:
            QMessageBox::information(this, "成功", "续借申请已提交，请等待管理员审核！");
            displayMyBorrowRecords();
            break;
        case Reader::RenewResult::NOT_FOUND:
            QMessageBox::warning(this, "失败", "续借失败！借阅记录不存在。");
            break;
        case Reader::RenewResult::ALREADY_PENDING:
            QMessageBox::warning(this, "失败", "续借失败！已有待审核的续借申请。");
            break;
        case Reader::RenewResult::HAS_OVERDUE:
            QMessageBox::warning(this, "失败", "续借失败！该图书已逾期，不能续借。");
            break;
        case Reader::RenewResult::EXCEED_LIMIT:
        {
            // （显示续借限制）：续借后借期不得超过策略规定的最大天数
            int maxRenewTimes = reader->getMaxRenewTimes();
            QMessageBox::warning(this, "失败", QString("续借失败！续借次数已达上限（最多续借%1次）。").arg(maxRenewTimes));
            break;
        }
        case Reader::RenewResult::LOW_CREDIT:
            QMessageBox::warning(this, "失败", "您因信用分下降被限制操作，暂时无法续借。");
            break;
        }
    }
}

/**
 * @brief 查找借阅记录
 *
 * 根据ISBN、书名、借阅时间、应还时间、归还时间、状态、
 * 续借状态和罚款状态等条件筛选借阅记录，并显示在表格中。
 */
void ReaderWindow::onSearchBorrow()
{
    QString isbn = borrowISBNEdit->text();
    QString title = borrowTitleEdit->text();
    QString time = borrowTimeEdit->text();
    QString dueTime = borrowDueTimeEdit->text();
    QString returnTime = borrowReturnTimeEdit->text();
    QString status = borrowStatusEdit->text();
    QString fineStatus = borrowFineCombo->currentText();
    QString renewStatus = borrowRenewCombo->currentText();

    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (!reader)
        return;

    double finePerDay = reader->getFinePerDay(); // 获取读者策略的罚款标准

    DataManager *dm = DataManager::getInstance();
    std::vector<BorrowRecord> allRecords = dm->getBorrowRecords();
    std::vector<BorrowRecord> filteredRecords;

    for (const auto &record : allRecords)
    {
        if (record.getReaderID() != reader->getID())
            continue;

        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 (!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(finePerDay);
            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)
            filteredRecords.push_back(record);
    }

    myBorrowTable->setRowCount(0);
    for (const auto &record : filteredRecords)
    {
        Book *book = dm->findBookByISBN(record.getISBN());
        int row = myBorrowTable->rowCount();
        myBorrowTable->insertRow(row);
        myBorrowTable->setItem(row, 0, new QTableWidgetItem(record.getISBN()));
        myBorrowTable->setItem(row, 1, new QTableWidgetItem(book ? book->getTitle() : "未知"));
        myBorrowTable->setItem(row, 2, new QTableWidgetItem(record.getBorrowTime().toString("yyyy-MM-dd hh:mm:ss")));
        myBorrowTable->setItem(row, 3, new QTableWidgetItem(record.getDueTime().toString("yyyy-MM-dd hh:mm:ss")));

        QString statusText;
        if (record.calculateOverdueDays() > 0)
            statusText = "逾期";
        else
            statusText = "正常";
        myBorrowTable->setItem(row, 4, new QTableWidgetItem(statusText));

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

        // 续借次数
        myBorrowTable->setItem(row, 6, new QTableWidgetItem(QString::number(record.getRenewCount())));

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

/**
 * @brief 支付所有罚款
 *
 * 计算当前读者的所有未支付罚款总额，调用读者的payAllFines方法进行支付，
 * 支付成功后发送消息通知读者，并更新借阅记录显示。
 */
void ReaderWindow::onPayAllFines()
{
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (!reader)
        return;

    double finePerDay = reader->getFinePerDay(); // 获取读者策略的罚款标准

    DataManager *dm = DataManager::getInstance();
    std::vector<BorrowRecord> &allRecords = dm->getBorrowRecords();

    double totalFine = 0;
    for (auto &record : allRecords)
    {
        if (record.getReaderID() == reader->getID())
        {
            totalFine += record.calculateFine(finePerDay) - record.getPaidFine();
        }
    }

    if (totalFine <= 0)
    {
        QMessageBox::information(this, "提示", "您当前没有需要支付的罚款。");
        return;
    }

    QMessageBox::StandardButton reply = QMessageBox::question(this, "确认支付",
                                                              QString("您当前需要支付罚款总额：%1元，是否确认支付？").arg(totalFine),
                                                              QMessageBox::Yes | QMessageBox::No);

    if (reply == QMessageBox::Yes)
    {
        for (auto &record : allRecords)
        {
            if (record.getReaderID() == reader->getID())
            {
                double remaining = record.calculateFine(finePerDay) - record.getPaidFine();
                if (remaining > 0)
                {
                    record.setPaidFine(record.calculateFine(finePerDay));
                    record.setFineStatus(BorrowRecord::FineStatus::PAID);
                }
            }
        }
        dm->writeBorrowRecord();

        // 发送消息给自己
        Message msg(reader->getID(), reader->getName(), QString("已成功支付所有罚款，共计：%1元").arg(totalFine));
        reader->addMessage(msg);
        dm->writeMessage();

        QMessageBox::information(this, "成功", QString("成功支付罚款：%1元").arg(totalFine));
        displayMyBorrowRecords();
    }
}

/**
 * @brief 切换到图书查询页面
 */
void ReaderWindow::switchToBookSearch()
{
    stackedWidget->setCurrentWidget(bookSearchWidget);
}

/**
 * @brief 切换到我的借阅页面
 */
void ReaderWindow::switchToMyBorrow()
{
    displayMyBorrowRecords();
    stackedWidget->setCurrentWidget(myBorrowWidget);
}

/**
 * @brief 切换到我的预约页面
 */
void ReaderWindow::switchToMyReservation()
{
    displayMyReservations();
    stackedWidget->setCurrentWidget(myReservationWidget);
}

/**
 * @brief 缴纳押金按钮点击槽函数
 *
 * 校外读者缴纳押金，缴纳后可使用借阅和预约功能。
 */
void ReaderWindow::onPayDeposit()
{
    ::ExternalReader *extReader = dynamic_cast<::ExternalReader *>(currentUser);
    if (!extReader)
        return;

    if (extReader->isDepositPaid())
    {
        QMessageBox::information(this, "提示", "您已缴纳押金，无需重复缴纳。");
        return;
    }

    double depositAmount = extReader->getDeposit();

    QMessageBox::StandardButton confirm = QMessageBox::question(
        this, "确认缴纳押金",
        QString("您需要缴纳押金 %1 元，缴纳后可使用借阅和预约功能。是否确认缴纳？").arg(depositAmount),
        QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);

    if (confirm == QMessageBox::Yes)
    {
        if (extReader->payDeposit())
        {
            QMessageBox::information(this, "成功", QString("押金缴纳成功！您已缴纳 %1 元押金，现在可以使用借阅和预约功能。").arg(depositAmount));
            updateInfoList();
        }
        else
        {
            QMessageBox::warning(this, "失败", "押金缴纳失败，请稍后重试。");
        }
    }
}

/**
 * @brief 退还押金按钮点击槽函数
 *
 * 校外读者申请退还押金，需确保无未归还图书和未结清罚款。
 */
void ReaderWindow::onRefundDeposit()
{
    ::ExternalReader *extReader = dynamic_cast<::ExternalReader *>(currentUser);
    if (!extReader)
        return;

    if (!extReader->isDepositPaid())
    {
        QMessageBox::information(this, "提示", "您尚未缴纳押金，无法退还。");
        return;
    }

    double depositAmount = extReader->getDeposit();

    QMessageBox::StandardButton confirm = QMessageBox::question(
        this, "确认退还押金",
        QString("确认退还押金 %1 元？退还后您将无法借阅和预约图书。").arg(depositAmount),
        QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);

    if (confirm == QMessageBox::Yes)
    {
        if (extReader->refundDeposit())
        {
            QMessageBox::information(this, "成功", QString("押金 %1 元已退还，感谢使用。").arg(depositAmount));
            updateInfoList();
        }
        else
        {
            QMessageBox::warning(this, "失败", "押金退还失败！请确保已归还所有图书且无未结清罚款。");
        }
    }
}

/**
 * @brief 显示输入对话框
 * @param title 对话框标题
 * @param label 输入框标签
 * @param isPassword 是否为密码输入
 * @return 输入的文本和是否取消（true表示取消）
 */
QPair<QString, bool> ReaderWindow::showInputDialog(const QString &title, const QString &label, bool isPassword)
{
    QDialog dialog(this);
    dialog.setWindowTitle(title);
    QVBoxLayout layout(&dialog);

    QLabel *labelWidget = new QLabel(label);
    layout.addWidget(labelWidget);

    QLineEdit *lineEdit = new QLineEdit();
    if (isPassword)
        lineEdit->setEchoMode(QLineEdit::Password);
    layout.addWidget(lineEdit);

    QDialogButtonBox buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
    layout.addWidget(&buttonBox);

    QObject::connect(&buttonBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
    QObject::connect(&buttonBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);

    int result = dialog.exec();
    if (result == QDialog::Accepted)
    {
        return qMakePair(lineEdit->text(), false);
    }
    return qMakePair("", true);
}

/**
 * @brief 设置消息管理页面
 *
 * 创建消息管理界面，包括操作按钮、查找输入框和消息列表。
 */
void ReaderWindow::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);

    // 消息查找输入框
    messageTimeEdit = new QLineEdit(this);
    messageTimeEdit->setPlaceholderText("消息时间");
    messageTimeEdit->setFixedWidth(150);

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

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

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

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

    // 连接信号槽
    connect(deleteMessageBtn, &QPushButton::clicked, this, &ReaderWindow::onDeleteMessage);
    connect(clearAllMessagesBtn, &QPushButton::clicked, this, &ReaderWindow::onClearAllMessages);
    connect(markAllReadBtn, &QPushButton::clicked, this, &ReaderWindow::onMarkAllRead);
    connect(searchMessageBtn, &QPushButton::clicked, this, &ReaderWindow::onSearchMessage);

    mainLayout->addLayout(topLayout);

    // 消息表格
    messageTable = new QTableWidget(this);
    messageTable->setColumnCount(3);
    QStringList headers = {"消息时间", "消息内容", "消息状态"};
    messageTable->setHorizontalHeaderLabels(headers);
    messageTable->horizontalHeader()->setStretchLastSection(true);
    messageTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    messageTable->setSelectionBehavior(QTableWidget::SelectRows);
    messageTable->setColumnWidth(0, 150);
    messageTable->setColumnWidth(1, 600);
    messageTable->setColumnWidth(2, 80);

    mainLayout->addWidget(messageTable);
}

/**
 * @brief 设置个人信息页面
 *
 * 创建个人信息展示界面，显示读者的基本信息。
 */
void ReaderWindow::setupInfoWidget()
{
    infoWidget = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(infoWidget);

    QLabel *titleLabel = new QLabel("个人信息", this);
    titleLabel->setAlignment(Qt::AlignCenter);
    QFont titleFont("Microsoft YaHei", 16, QFont::Bold);
    titleLabel->setFont(titleFont);
    titleLabel->setStyleSheet("padding: 20px; color: #333;");

    infoListWidget = new QListWidget(this);
    infoListWidget->setStyleSheet("QListWidget { border: 2px solid #ddd; border-radius: 5px; padding: 10px; background: transparent; }"
                                  "QListWidget::item { padding: 12px; border-bottom: 1px solid #eee; background: transparent; }"
                                  "QListWidget::item:last { border-bottom: none; }"
                                  "QListWidget::item:hover { background: transparent; }"
                                  "QListWidget::item:selected { background: transparent; border: none; outline: none; }"
                                  "QListWidget::item:focus { outline: none; }");
    infoListWidget->setSelectionMode(QAbstractItemView::NoSelection);

    mainLayout->addWidget(titleLabel);
    mainLayout->addWidget(infoListWidget);

    // （押金按钮）：校外读者显示缴纳/退还押金按钮
    ::Reader *reader = dynamic_cast<::Reader *>(currentUser);
    ::ExternalReader *extReader = dynamic_cast<::ExternalReader *>(reader);
    if (extReader)
    {
        QHBoxLayout *depositLayout = new QHBoxLayout();

        payDepositBtn = new QPushButton("缴纳押金", this);
        payDepositBtn->setStyleSheet("QPushButton { padding: 8px 16px; background-color: #4CAF50; color: white; border: none; border-radius: 4px; font-size: 14px; }"
                                     "QPushButton:hover { background-color: #45a049; }");

        refundDepositBtn = new QPushButton("退还押金", this);
        refundDepositBtn->setStyleSheet("QPushButton { padding: 8px 16px; background-color: #ff9800; color: white; border: none; border-radius: 4px; font-size: 14px; }"
                                        "QPushButton:hover { background-color: #e68a00; }");

        depositLayout->addWidget(payDepositBtn);
        depositLayout->addWidget(refundDepositBtn);
        depositLayout->addStretch();
        mainLayout->addLayout(depositLayout);

        connect(payDepositBtn, &QPushButton::clicked, this, &ReaderWindow::onPayDeposit);
        connect(refundDepositBtn, &QPushButton::clicked, this, &ReaderWindow::onRefundDeposit);
    }
    else
    {
        payDepositBtn = nullptr;
        refundDepositBtn = nullptr;
    }
}

/**
 * @brief 切换到个人信息页面
 */
void ReaderWindow::switchToInfo()
{
    updateInfoList();
    stackedWidget->setCurrentWidget(infoWidget);
}

/**
 * @brief 更新个人信息列表
 *
 * 更新显示当前读者的个人信息，包括ID、用户名、角色、手机号、邮箱、
 * 信用分和借阅策略信息（最大借阅数、借阅天数、续借天数、罚款标准等）。
 */
void ReaderWindow::updateInfoList()
{
    ::Reader *reader = dynamic_cast<::Reader *>(currentUser);
    if (!reader)
        return;

    infoListWidget->clear();

    infoListWidget->addItem(QString("ID：%1").arg(reader->getID()));
    infoListWidget->addItem(QString("用户名：%1").arg(reader->getName()));
    infoListWidget->addItem(QString("角色：%1").arg(reader->getRoleString()));
    infoListWidget->addItem(QString("手机号：%1").arg(reader->getPhone()));
    infoListWidget->addItem(QString("邮箱：%1").arg(reader->getEmail()));
    infoListWidget->addItem(QString("信用分：%1").arg(reader->getCreditScore()));

    infoListWidget->addItem("─── 借阅策略 ───");
    infoListWidget->addItem(QString("  最大借阅数：%1本").arg(reader->getMaxBooks()));
    infoListWidget->addItem(QString("  借阅天数：%1天").arg(reader->getBorrowDays()));
    infoListWidget->addItem(QString("  续借延长：%1天").arg(reader->getRenewDays()));
    infoListWidget->addItem(QString("  最大续借次数：%1次").arg(reader->getMaxRenewTimes()));
    infoListWidget->addItem(QString("  逾期罚款：%1元/天").arg(reader->getFinePerDay()));

    // （显示押金状态）：校外读者显示押金缴纳状态
    ::ExternalReader *extReader = dynamic_cast<::ExternalReader *>(reader);
    if (extReader)
    {
        QString depositStatus = extReader->isDepositPaid() ? "已缴纳" : "未缴纳";
        infoListWidget->addItem(QString("  押金：%1元（%2）").arg(extReader->getDeposit()).arg(depositStatus));
    }

    for (int i = 0; i < infoListWidget->count(); ++i)
    {
        QListWidgetItem *item = infoListWidget->item(i);
        item->setFont(QFont("Microsoft YaHei", 12));
        item->setTextAlignment(Qt::AlignLeft);
    }
}

/**
 * @brief 显示消息列表
 * @param messages 消息列表
 *
 * 将消息列表显示在消息表格中，包括消息时间、消息内容和消息状态。
 */
void ReaderWindow::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.getReaderDisplayFields();

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

    // 设置列宽
    messageTable->setColumnWidth(0, 150);
    messageTable->setColumnWidth(1, 600);
    messageTable->setColumnWidth(2, 80);
}

/**
 * @brief 查看消息
 *
 * 切换到消息管理页面并显示当前读者的消息列表。
 */
void ReaderWindow::onCheckMessages()
{
    Reader *reader = dynamic_cast<Reader *>(currentUser);
    if (!reader)
    {
        return;
    }

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

/**
 * @brief 退出登录
 *
 * 弹出确认对话框，确认后发送logout信号并关闭窗口。
 */
void ReaderWindow::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 ReaderWindow::onDeleteMessage()
{
    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)
    {
        currentUser->deleteMessage(currentRow);
        DataManager::getInstance()->writeMessage();
        displayMessages(currentUser->getMessages());

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

/**
 * @brief 清除所有消息
 *
 * 清除当前读者的所有消息，更新消息列表并保存到文件。
 */
void ReaderWindow::onClearAllMessages()
{
    QMessageBox confirmBox(QMessageBox::Question, "确认清除", "确定要清除所有消息吗？此操作不可恢复！", QMessageBox::NoButton, this);
    QAbstractButton *yesBtn = confirmBox.addButton("是", QMessageBox::YesRole);
    confirmBox.addButton("否", QMessageBox::NoRole);
    confirmBox.exec();

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

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

/**
 * @brief 全部设为已读
 *
 * 将所有未读消息标记为已读，更新消息列表并保存到文件。
 */
void ReaderWindow::onMarkAllRead()
{
    std::vector<Message> &messages = currentUser->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 查找消息
 *
 * 根据消息时间、消息内容和消息状态等条件筛选消息，并显示在消息表格中。
 */
void ReaderWindow::onSearchMessage()
{
    QString time = messageTimeEdit->text().trimmed();
    QString content = messageContentEdit->text().trimmed();
    QString status = messageStatusCombo->currentText().trimmed();

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

    // 如果所有条件都为空，显示全部消息
    if (time.isEmpty() && content.isEmpty() && status.isEmpty())
    {
        displayMessages(allMessages);
        return;
    }

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

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

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

    displayMessages(filteredMessages);
}