mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <thread>
#include <QDir>
#include <QDebug>
#include <QMessageBox>
#include <QTextCodec>
#include <QFileDialog>
#include <QDateTime>
#include <QApplication>
#include <QDialog>
#include <QDialogButtonBox>
#include <QFile>
#include <QLabel>
#include <QListWidgetItem>
#include <QMenu>
#include <QImageReader>
#include <QCloseEvent>
#include <QScreen>
#include <QShowEvent>
#include <QTextEdit>
#include <QTimer>
#include <QVBoxLayout>
#include <QtMac>
#include "addfellowdialog.h"
#include <QProcess>
#include "platformdepend.h"
#include "feiqwin.h"
#include "emoji.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    ui->menuBar->setNativeMenuBar(false);
    applyDarkTheme();
    mFellowStatusLabel = new QLabel(this);
    mFellowStatusLabel->setAlignment(Qt::AlignCenter);
    mFellowStatusLabel->setMinimumHeight(32);
    ui->verticalLayout->insertWidget(0, mFellowStatusLabel);
    updateFellowStatusHeader();

    qRegisterMetaType<shared_ptr<ViewEvent>>("ViewEventSharedPtr");
    qRegisterMetaType<shared_ptr<ViewEvent>>("shared_ptr<ViewEvent>");

    connect(this, SIGNAL(showErrorAndQuit(QString)), this, SLOT(onShowErrorAndQuit(QString)));

    //加载配置
    auto settingFilePath = QDir::home().filePath(".feiq_setting.ini");
    mSettings = new Settings(settingFilePath, QSettings::IniFormat);
    mSettings->setIniCodec(QTextCodec::codecForName("UTF-8"));
    mTitle = mSettings->value("app/title", "yanbo聊天系统").toString();
    if (mTitle == "mac飞秋")
        mTitle = "yanbo聊天系统";
    setWindowTitle(mTitle);

    //初始化搜索对话框
    mSearchFellowDlg = new SearchFellowDlg(this);
    connect(mSearchFellowDlg, SIGNAL(onFellowSelected(const Fellow*)),
            this, SLOT(finishSearch(const Fellow*)));

    connect(ui->actionRefreshFellows, SIGNAL(triggered(bool)), this, SLOT(refreshFellowList()));
    connect(ui->actionAddFellow, SIGNAL(triggered(bool)), this, SLOT(addFellow()));

    mSearchFellowDlg->setSearchDriver(std::bind(&MainWindow::fellowSearchDriver, this, placeholders::_1));

    //初始化文件管理对话框
    mDownloadFileDlg = new FileManagerDlg(this);
    mDownloadFileDlg->setEngine(&mFeiq);
    connect(this, SIGNAL(statChanged(FileTask*)), mDownloadFileDlg, SLOT(statChanged(FileTask*)));
    connect(this, SIGNAL(progressChanged(FileTask*)), mDownloadFileDlg, SLOT(progressChanged(FileTask*)));

    //初始化好友列表
    mFellowList.bindTo(ui->fellowListWidget);
    connect(&mFellowList, SIGNAL(select(const Fellow*)), this, SLOT(openChartTo(const Fellow*)));
    ui->fellowListWidget->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(ui->fellowListWidget, SIGNAL(customContextMenuRequested(QPoint)),
            this, SLOT(showFellowContextMenu(QPoint)));

    //初始化接收文本框
    mRecvTextEdit = ui->recvEdit;
    connect(mRecvTextEdit, SIGNAL(navigateToFileTask(IdType,IdType,bool)), this, SLOT(navigateToFileTask(IdType,IdType,bool)));

    //初始化发送文本框
    mSendTextEdit = ui->sendEdit;
    connect(mSendTextEdit, SIGNAL(acceptDropFiles(QList<QFileInfo>)), this, SLOT(sendFiles(QList<QFileInfo>)));
    connect(mSendTextEdit, SIGNAL(acceptPasteImages(QList<QFileInfo>)), this, SLOT(sendImages(QList<QFileInfo>)));
    connect(mSendTextEdit, SIGNAL(enterPressed()), this, SLOT(sendText()));
    connect(mSendTextEdit, SIGNAL(ctrlEnterPressed()), mSendTextEdit, SLOT(newLine()));

    //初始化Emoji对话框
    mChooseEmojiDlg = new ChooseEmojiDlg(this);
    connect(ui->actionInsertEmoji, SIGNAL(triggered(bool)), this, SLOT(openChooseEmojiDlg()));
    connect(mChooseEmojiDlg, SIGNAL(choose(QString)),mSendTextEdit, SLOT(insertEmoji(QString)));

    //初始化菜单
    connect(ui->actionSearchFellow, SIGNAL(triggered(bool)), this, SLOT(openSearchDlg()));
    connect(ui->actionSettings, SIGNAL(triggered(bool)), this, SLOT(openSettings()));
    connect(ui->actionOpendl, SIGNAL(triggered(bool)), this, SLOT(openDownloadDlg()));
    connect(ui->actionSendText, SIGNAL(triggered(bool)), this, SLOT(sendText()));
    connect(ui->actionSendKnock, SIGNAL(triggered(bool)), this, SLOT(sendKnock()));
    connect(ui->actionSendFile, SIGNAL(triggered(bool)), this, SLOT(sendFile()));
    connect(ui->uploadFileBtn, SIGNAL(clicked(bool)), this, SLOT(sendFile()));
    connect(ui->uploadImageBtn, SIGNAL(clicked(bool)), this, SLOT(sendImage()));
    connect(ui->downloadFileBtn, SIGNAL(clicked(bool)), this, SLOT(openDownloadDlg()));
    connect(ui->emojiBtn, SIGNAL(clicked(bool)), this, SLOT(openChooseEmojiDlg()));
    connect(ui->sendTextBtn, SIGNAL(clicked(bool)), this, SLOT(sendText()));

    //初始化平台相关特性
    PlatformDepend::instance().setMainWnd(this);

    //初始化飞秋引擎
    connect(this, SIGNAL(feiqViewEvent(shared_ptr<ViewEvent>)), this, SLOT(handleFeiqViewEvent(shared_ptr<ViewEvent>)));

    //后台初始化通信
    enterFellowListMode();

    std::thread thd(&MainWindow::initFeiq, this);
    thd.detach();
}

MainWindow::~MainWindow()
{
    mFeiq.stop();
    mSettings->sync();
    delete mSettings;
    delete mSearchFellowDlg;
    delete mDownloadFileDlg;
    delete mChooseEmojiDlg;
    delete ui;
}

void MainWindow::setFeiqWin(FeiqWin *feiqWin)
{
    mFeiqWin = feiqWin;
    mFeiqWin->init(this);
}

void MainWindow::applyDarkTheme()
{
    qApp->setStyleSheet(
        "QMainWindow, QDialog, QWidget {"
        "  background-color: #080c12;"
        "  color: #d7e1ec;"
        "  selection-background-color: #1f7aff;"
        "  selection-color: #ffffff;"
        "}"
        "QMenuBar {"
        "  background-color: #0d131d;"
        "  color: #d7e1ec;"
        "  border-bottom: 1px solid #1f2d3d;"
        "}"
        "QMenuBar::item:selected, QMenu::item:selected {"
        "  background-color: #12385c;"
        "}"
        "QMenu {"
        "  background-color: #0d131d;"
        "  color: #d7e1ec;"
        "  border: 1px solid #26415c;"
        "}"
        "QListWidget, QTextEdit, QLineEdit, QTableWidget {"
        "  background-color: #0f1720;"
        "  color: #d7e1ec;"
        "  border: 1px solid #26384a;"
        "  border-radius: 4px;"
        "}"
        "QListWidget::item {"
        "  padding: 5px 6px;"
        "  border-bottom: 1px solid #162231;"
        "}"
        "QListWidget::item:selected {"
        "  background-color: #17446f;"
        "  color: #ffffff;"
        "}"
        "QLabel {"
        "  background-color: #0d131d;"
        "  color: #d7e1ec;"
        "  border: 1px solid #26384a;"
        "  border-radius: 4px;"
        "  padding: 6px;"
        "}"
        "QToolButton, QPushButton {"
        "  background-color: #152233;"
        "  color: #e8f1fb;"
        "  border: 1px solid #2f8cff;"
        "  border-radius: 4px;"
        "  padding: 5px 10px;"
        "}"
        "QToolButton:hover, QPushButton:hover {"
        "  background-color: #1f3955;"
        "}"
        "QToolButton:pressed, QPushButton:pressed {"
        "  background-color: #256dba;"
        "}"
        "QHeaderView::section {"
        "  background-color: #121d2b;"
        "  color: #d7e1ec;"
        "  border: 1px solid #26384a;"
        "  padding: 4px;"
        "}"
        "QScrollBar:vertical, QScrollBar:horizontal {"
        "  background: #0b1119;"
        "  width: 10px;"
        "  height: 10px;"
        "}"
        "QScrollBar::handle:vertical, QScrollBar::handle:horizontal {"
        "  background: #31516f;"
        "  border-radius: 4px;"
        "}"
    );
}

void MainWindow::updateFellowStatusHeader()
{
    if (mFellowStatusLabel == nullptr)
        return;

    mFellowStatusLabel->setText(QString("在线好友 %1  |  离线好友 %2")
                                .arg(mFellowList.onlineCount())
                                .arg(mFellowList.offlineCount()));
}

void MainWindow::positionFellowListWindow(bool collapsed)
{
    if (mChatMode)
        return;

    const int width = 240;
    const int expandedHeight = 680;
    const int collapsedHeight = 48;
    const int height = collapsed ? collapsedHeight : expandedHeight;

    setFixedSize(width, height);
    resize(width, height);

    auto targetScreen = screen();
    if (targetScreen == nullptr)
        targetScreen = QApplication::primaryScreen();
    if (targetScreen == nullptr)
        return;

    auto area = targetScreen->availableGeometry();
    auto x = area.right() - width + 1;
    auto y = area.top();
    move(x, y);
    mFellowListCollapsed = collapsed;
}

void MainWindow::enterFellowListMode()
{
    if (mChatMode)
        mChatWindowSize = size();

    mChatMode = false;
    setWindowTitle(mTitle);
    mRecvTextEdit->setCurFellow(nullptr);

    ui->menuBar->hide();
    ui->recvEdit->hide();
    ui->sendEdit->hide();
    ui->uploadFileBtn->hide();
    ui->uploadImageBtn->hide();
    ui->downloadFileBtn->hide();
    ui->emojiBtn->hide();
    ui->sendTextBtn->hide();
    mFellowStatusLabel->show();

    ui->fellowListWidget->setFixedWidth(220);
    setFixedWidth(240);
    positionFellowListWindow(true);
}

void MainWindow::enterChatMode()
{
    mChatMode = true;

    setMinimumHeight(0);
    setMaximumHeight(QWIDGETSIZE_MAX);
    setMaximumWidth(QWIDGETSIZE_MAX);
    setMinimumSize(744, 576);
    ui->fellowListWidget->setFixedWidth(180);

    ui->menuBar->show();
    ui->recvEdit->show();
    ui->sendEdit->show();
    ui->uploadFileBtn->show();
    ui->uploadImageBtn->show();
    ui->downloadFileBtn->show();
    ui->emojiBtn->show();
    ui->sendTextBtn->show();
    mFellowStatusLabel->show();

    if (mChatWindowSize.isValid())
        resize(mChatWindowSize);
    else
        resize(744, 576);
}

void MainWindow::onNotifyClicked(const QString& fellowIp)
{
    qDebug()<<fellowIp;
    auto fellow = mFeiq.getModel().findFirstFellowOf(fellowIp.toStdString());
    if (fellow)
        openChartTo(fellow.get());

    raise();
    activateWindow();
    showNormal();
}

void MainWindow::onNotifyReplied(long notifyId, const QString &fellowIp, const QString &reply)
{
    auto fellow = mFeiq.getModel().findFirstFellowOf(fellowIp.toStdString());
    if (fellow)
    {
        //回复消息
        auto content = make_shared<TextContent>();
        content->text = reply.toStdString();

        mFeiq.send(fellow, content);

        //设为已回复
        auto msgRepliedTo = findUnshownMessage(notifyId);
        if (msgRepliedTo)
        {
            msgRepliedTo->replied=true;
        }

        //将自己的回复放入未显示列表
        auto event = make_shared<MessageViewEvent>();
        event->contents.push_back(content);
        event->fellow = nullptr;

        auto& msg = addUnshownMessage(fellow.get(), event);
        msg.read = true;

        updateUnshownHint(fellow.get());
    }
}

void MainWindow::showEvent(QShowEvent *event)
{
    QMainWindow::showEvent(event);
    if (!mChatMode)
        QTimer::singleShot(0, this, [this](){ positionFellowListWindow(true); });
}

void MainWindow::enterEvent(QEvent *event)
{
    if (!mChatMode && mFellowListCollapsed)
        positionFellowListWindow(false);

    auto fellow = mRecvTextEdit->curFellow();
    if (fellow)
    {
        flushUnshown(fellow);
        updateUnshownHint(fellow);
    }

    PlatformDepend::instance().hideAllNotify();
    QMainWindow::enterEvent(event);
}

void MainWindow::leaveEvent(QEvent *event)
{
    if (!mChatMode && !mFellowListCollapsed && !mContextMenuOpen)
        positionFellowListWindow(true);

    QMainWindow::leaveEvent(event);
}

void MainWindow::closeEvent(QCloseEvent *event)
{
    if (mChatMode)
    {
        enterFellowListMode();
        event->ignore();
        return;
    }

    QMainWindow::closeEvent(event);
}

void MainWindow::openChartTo(const Fellow *fellow)
{
    enterChatMode();
    mFellowList.top(*fellow);
    mRecvTextEdit->setCurFellow(fellow);
    setWindowTitle(mTitle + " - 与"+fellow->getName().c_str()+"会话中");
    flushUnshown(fellow);
    updateUnshownHint(fellow);
}

shared_ptr<Fellow> MainWindow::checkCurFellow()
{
    auto fellow = mFeiq.getModel().getShared(mRecvTextEdit->curFellow());
    if (fellow == nullptr)
    {
        mRecvTextEdit->addWarning("这是要发给谁？");
    }

    return fellow;
}

void MainWindow::showResult(pair<bool, string> ret, const Content* content)
{
    if (ret.first)
    {
        auto now = QDateTime::currentDateTime().currentMSecsSinceEpoch();
        mRecvTextEdit->addMyContent(content, now);
        appendHistory(mRecvTextEdit->curFellow(), content, true, now);
    }
    else
    {
        mRecvTextEdit->addWarning(ret.second.c_str());
    }
}

void MainWindow::onStateChanged(FileTask *fileTask)
{
    if (fileTask->getState()==FileTaskState::Finish)
    {
        auto title = QString(fileTask->getTaskTypeDes().c_str())+"完成";
        PlatformDepend::instance().showNotify(title,
                                              fileTask->getContent()->filename.c_str(),
                                              fileTask->fellow()->getIp().c_str());

        auto content = fileTask->getContent();
        if (fileTask->type() == FileTaskType::Download
            && (content->fileType & IPMSG_FILE_CLIPBOARD))
        {
            auto event = make_shared<MessageViewEvent>();
            event->fellow = fileTask->fellow();
            event->contents.push_back(static_pointer_cast<Content>(content));
            emit feiqViewEvent(event);
        }
    }
    else if (fileTask->getState()==FileTaskState::Error)
    {
        auto title = QString(fileTask->getTaskTypeDes().c_str())+"失败";
        auto content = QString(fileTask->getContent()->filename.c_str());
        content += "\n";
        content += fileTask->getDetailInfo().c_str();
        PlatformDepend::instance().showNotify(title,
                                              content,
                                              fileTask->fellow()->getIp().c_str());
    }

    if (mDownloadFileDlg->isVisible())
    {
        emit statChanged(fileTask);
    }
}

void MainWindow::onProgress(FileTask *fileTask)
{
    if (mDownloadFileDlg->isVisible())
    {
        emit progressChanged(fileTask);
    }
}

void MainWindow::onEvent(shared_ptr<ViewEvent> event)
{
    emit feiqViewEvent(event);
}

void MainWindow::onShowErrorAndQuit(const QString &text)
{
    qCritical()<<"feiq startup failed:"<<text;
    QMessageBox::warning(this, "出错了，为什么？你猜！", text, "退出应用");

    QApplication::exit(-1);
}

void MainWindow::handleFeiqViewEvent(shared_ptr<ViewEvent> event)
{
    if (event->what == ViewEventType::FELLOW_UPDATE)
    {
        auto e = static_cast<FellowViewEvent*>(event.get());
        mFellowList.update(*(e->fellow.get()));
        updateUnshownHint(e->fellow.get());
        updateFellowStatusHeader();
    }
    else if (event->what == ViewEventType::SEND_TIMEO || event->what == ViewEventType::MESSAGE)
    {
        //地球人都知道这个分支中的ViewEvent继承自FellowViewEvent
        auto e = static_cast<FellowViewEvent*>(event.get());
        auto fellow = e->fellow.get();

        if (isActiveWindow() && fellow == mRecvTextEdit->curFellow())
        {//窗口可见，处理当前用户消息，其他用户消息则放入通知队列
            readEvent(event.get());
        }
        else
        {//窗口不可见，放入未读队列并通知
            auto& umsg = addUnshownMessage(fellow, event);
            notifyUnshown(umsg);
            updateUnshownHint(fellow);
        }
    }
}

void MainWindow::refreshFellowList()
{
    mFeiq.sendImOnLine();
}

void MainWindow::addFellow()
{
    AddFellowDialog dlg(this);
    if (dlg.exec() == QDialog::Accepted)
    {
        auto ip = dlg.getIp();
        userAddFellow(ip);
    }
}

void MainWindow::openChooseEmojiDlg()
{
    mChooseEmojiDlg->exec();
}

void MainWindow::sendFiles(QList<QFileInfo> files)
{
    auto fellow = checkCurFellow();
    if (!fellow)
        return;

    for (auto file : files)
    {
        if (file.isFile())
        {
            sendFile(file.absoluteFilePath().toStdString());
        }
        else
        {
            mRecvTextEdit->addWarning("不支持发送："+file.absoluteFilePath());
        }
    }
}

void MainWindow::userAddFellow(QString ip)
{
    //创建好友
    auto fellow = make_shared<Fellow>();
    fellow->setIp(ip.toStdString());
    fellow->setOnLine(true);
    mFeiq.getModel().addFellow(fellow);

    //添加到列表
    auto& ref = *(fellow.get());
    mFellowList.update(ref);
    updateFellowStatusHeader();
    mFellowList.top(ref);

    //发送在线
    mFeiq.sendImOnLine(fellow->getIp());
}

void MainWindow::notifyUnshown(UnshownMessage& umsg)
{
    auto event = umsg.event.get();
    if (event->what == ViewEventType::SEND_TIMEO)
    {
        auto e = static_cast<const SendTimeoEvent*>(event);
        auto fellow = e->fellow.get();
        umsg.notifyId = showNotification(fellow, "发送超时:"+simpleTextOf(e->content.get()));
    }
    else if (event->what == ViewEventType::MESSAGE)
    {
        auto e = static_cast<const MessageViewEvent*>(event);
        auto fellow = e->fellow.get();
        QString text="";
        bool first=false;
        for (auto content : e->contents)
        {
            auto t = simpleTextOf(content.get());
            if (first)
                text = t;
            else
                text = text+"\n"+t;
        }
        umsg.notifyId = showNotification(fellow, text);
    }
}

long MainWindow::showNotification(const Fellow *fellow, const QString &text)
{
    QString content(text);
    if (content.length()>100)
        content = content.left(100)+"...";
    return PlatformDepend::instance().showNotify(QString(fellow->getName().c_str())+":", content, fellow->getIp().c_str());
}

void MainWindow::navigateToFileTask(IdType packetNo, IdType fileId, bool upload)
{
    auto task = mFeiq.getModel().findTask(packetNo, fileId, upload ? FileTaskType::Upload : FileTaskType::Download);
    openDownloadDlg();
    mDownloadFileDlg->select(task.get());
}

void MainWindow::sendFile(std::string filepath)
{
    if (QImageReader(QString::fromStdString(filepath)).canRead())
    {
        sendImage(filepath);
        return;
    }

    auto content = FileContent::createFileContentToSend(filepath);
    auto fellow = checkCurFellow();
    if (!fellow)
        return;

    if (content == nullptr)
    {
        mRecvTextEdit->addWarning("获取文件"+QString(filepath.c_str())+"的信息失败，不发送");
    }
    else
    {
        auto fileContent = shared_ptr<FileContent>(std::move(content));
        auto ret = mFeiq.send(fellow, fileContent);
        showResult(ret, fileContent.get());
    }
}

void MainWindow::sendImage(std::string filepath)
{
    auto fellow = checkCurFellow();
    if (!fellow)
        return;

    if (!QImageReader(QString::fromStdString(filepath)).canRead())
    {
        mRecvTextEdit->addWarning("这不是支持的图片文件："+QString::fromStdString(filepath));
        return;
    }

    auto content = ImageContent::createImageContentToSend(filepath);
    if (content == nullptr)
    {
        mRecvTextEdit->addWarning("获取图片"+QString::fromStdString(filepath)+"的信息失败，不发送");
    }
    else
    {
        auto imageContent = shared_ptr<ImageContent>(std::move(content));
        auto ret = mFeiq.send(fellow, imageContent);
        showResult(ret, imageContent.get());
    }
}

void MainWindow::sendImages(QList<QFileInfo> files)
{
    auto fellow = checkCurFellow();
    if (!fellow)
        return;

    for (auto file : files)
    {
        if (file.isFile())
        {
            sendImage(file.absoluteFilePath().toStdString());
        }
        else
        {
            mRecvTextEdit->addWarning("不支持发送："+file.absoluteFilePath());
        }
    }
}

void MainWindow::sendImage()
{
    auto fellow = checkCurFellow();
    if (!fellow)
        return;

    QFileDialog fdlg(this, "选择要发送的图片");
    fdlg.setFileMode(QFileDialog::ExistingFiles);
    fdlg.setNameFilter("图片 (*.png *.jpg *.jpeg *.bmp *.gif *.webp);;所有文件 (*)");
    if (fdlg.exec() == QDialog::Accepted)
    {
        auto list = fdlg.selectedFiles();
        auto count = list.count();
        for (int i = 0; i < count; i++)
        {
            auto path = list.at(i);
            sendImage(path.toStdString());
        }
    }
}

void MainWindow::sendFile()
{
    auto fellow = checkCurFellow();
    if (!fellow)
        return;

    //文件多选
    QFileDialog fdlg(this, "选择要发送的文件");
    fdlg.setFileMode(QFileDialog::ExistingFiles);
    if (fdlg.exec() == QDialog::Accepted)
    {
        auto list = fdlg.selectedFiles();
        auto count = list.count();
        for (int i = 0; i < count; i++)
        {
            auto path = list.at(i);
            sendFile(path.toStdString());
        }
    }
}

void MainWindow::sendKnock()
{
    auto fellow = checkCurFellow();
    if (fellow)
    {
        auto content = make_shared<KnockContent>();
        auto ret = mFeiq.send(fellow, content);
        showResult(ret, content.get());
    }
}

void MainWindow::sendText()
{
    auto text = mSendTextEdit->textWithEmojiCode();
    if (text.isEmpty())
    {
        mRecvTextEdit->addWarning("发送空文本是不科学的，驳回");
        return;
    }


    auto fellow = checkCurFellow();
    if (fellow)
    {
        auto content = make_shared<TextContent>();
        content->text = text.toStdString();
        auto ret = mFeiq.send(fellow, content);
        showResult(ret, content.get());
        mSendTextEdit->clear();
    }
}

void MainWindow::finishSearch(const Fellow *fellow)
{
    mFellowList.top(*fellow);
    openChartTo(fellow);
}

void MainWindow::openSettings()
{
    QMessageBox::information(this, "设置", "设置文件在:"+mSettings->fileName()+"\n重启后生效",
                             QMessageBox::Ok);
}

void MainWindow::openSearchDlg()
{
    mSearchFellowDlg->exec();
}

void MainWindow::openDownloadDlg()
{
    mDownloadFileDlg->refresh();
    mDownloadFileDlg->show();
    mDownloadFileDlg->raise();
}

void MainWindow::showFellowContextMenu(const QPoint &pos)
{
    auto item = ui->fellowListWidget->itemAt(pos);
    const Fellow* fellow = nullptr;
    if (item != nullptr)
        fellow = static_cast<const Fellow*>(item->data(Qt::UserRole).value<void*>());

    QMenu menu(this);
    QAction* chatAction = nullptr;
    QAction* historyAction = nullptr;
    QAction* sendFileAction = nullptr;
    QAction* sendImageAction = nullptr;
    if (fellow != nullptr)
    {
        auto ipAction = menu.addAction("IP: "+QString::fromStdString(fellow->getIp()));
        ipAction->setEnabled(false);
        menu.addSeparator();
        if (mChatMode)
            chatAction = menu.addAction("开始会话");
        historyAction = menu.addAction("查看历史记录");
        if (mChatMode)
        {
            sendFileAction = menu.addAction("发送文件");
            sendImageAction = menu.addAction("发送图片");
        }
        menu.addSeparator();
    }
    auto refreshAction = menu.addAction("刷新用户");

    mContextMenuOpen = true;
    auto selected = menu.exec(ui->fellowListWidget->viewport()->mapToGlobal(pos));
    mContextMenuOpen = false;
    if (selected == nullptr)
    {
        if (!mChatMode && !rect().contains(mapFromGlobal(QCursor::pos())))
            positionFellowListWindow(true);
        return;
    }
    else if (selected == refreshAction)
    {
        refreshFellowList();
    }
    else if (selected == chatAction && fellow != nullptr)
    {
        openChartTo(fellow);
    }
    else if (selected == historyAction && fellow != nullptr)
    {
        showHistory(fellow);
    }
    else if (selected == sendFileAction && fellow != nullptr)
    {
        openChartTo(fellow);
        sendFile();
    }
    else if (selected == sendImageAction && fellow != nullptr)
    {
        openChartTo(fellow);
        sendImage();
    }

    if (!mChatMode && !rect().contains(mapFromGlobal(QCursor::pos())))
        positionFellowListWindow(true);
}

vector<const Fellow *> MainWindow::fellowSearchDriver(const QString &text)
{
    auto fellows = mFeiq.getModel().searchFellow(text.toStdString());
    vector<const Fellow*> result;
    for (auto fellow : fellows)
    {
        result.push_back(fellow.get());
    }
    return result;
}

void MainWindow::initFeiq()
{
    //配置飞秋
    auto name = mSettings->value("user/name").toString();
    if (name.isEmpty())
    {
        emit showErrorAndQuit("请先打开【"+mSettings->fileName()+"】设置用户名(user/name)");
        return;
    }

    mFeiq.setMyName(name.toStdString());
    mFeiq.setMyHost(mSettings->value("user/host","feiq by cy").toString().toStdString());

    auto customGrroup = mSettings->value("network/custom_group", "").toString();
    if (!customGrroup.isEmpty())
    {
        auto list = customGrroup.split("|");
        for (int i = 0; i < list.size(); i++)
        {
            QString ipPrefix = list[i];
            if (ipPrefix.endsWith("."))
            {
                for (int j = 2; j < 254; j++)
                {
                    auto ip = ipPrefix+QString::number(j);
                    mFeiq.addToBroadcast(ip.toStdString());
                }
            }
        }
    }

    mFeiq.setView(this);

    //启动飞秋
    auto ret = mFeiq.start();
    if (!ret.first)
    {
        emit showErrorAndQuit(ret.second.c_str());
        return;
    }

    mFeiq.enableIntervalDetect(60);

    qDebug()<<"feiq started";
}

void MainWindow::updateUnshownHint(const Fellow *fellow)
{
    auto it = mUnshownEvents.find(fellow);
    if (it != mUnshownEvents.end())
    {
        auto count = 0;
        for (auto& msg : it->second)
        {
            if (msg.isUnread())
                ++count;
        }

        if (count == 0)
        {
            mFellowList.mark(*fellow, "");
        }
        else
        {
            mFellowList.mark(*fellow, QString::number(count));
        }
    }

    setBadgeNumber(getUnreadCount());
}

int MainWindow::getUnreadCount()
{
    auto begin = mUnshownEvents.begin();
    auto end = mUnshownEvents.end();
    auto count = 0;
    for (auto it = begin; it != end; it++)
    {
        for (auto msg : it->second)
        {
            if (msg.isUnread())
                ++count;
        }
    }
    return count;
}

void MainWindow::flushUnshown(const Fellow *fellow)
{
    auto it = mUnshownEvents.find(fellow);
    if (it != mUnshownEvents.end())
    {
        auto& list = (*it).second;
        while (!list.empty())
        {
            auto msg = list.front();
            readEvent(msg.event.get());
            list.pop_front();
        }
    }
}

void MainWindow::readEvent(const ViewEvent *event)
{
    if (event->what == ViewEventType::SEND_TIMEO)
    {
        auto e = static_cast<const SendTimeoEvent*>(event);
        auto simpleText = simpleTextOf(e->content.get());
        if (simpleText.length()>20){
            simpleText = simpleText.left(20)+"...";
        }
        mRecvTextEdit->addWarning("发送超时:"+simpleText);
    }
    else if (event->what == ViewEventType::MESSAGE)
    {
        auto e = static_cast<const MessageViewEvent*>(event);
        auto time =  e->when.time_since_epoch().count();
        for (auto content : e->contents)
        {
            if (e->fellow == nullptr)
            {
                mRecvTextEdit->addMyContent(content.get(), time);
                appendHistory(mRecvTextEdit->curFellow(), content.get(), true, time);
            }
            else
            {
                mRecvTextEdit->addFellowContent(content.get(), time);
                appendHistory(e->fellow.get(), content.get(), false, time);
            }
        }
    }
}

void MainWindow::setBadgeNumber(int number)
{
    PlatformDepend::instance().setBadgeNumber(number);
}

QString MainWindow::simpleTextOf(const Content *content)
{
    switch (content->type()) {
    case ContentType::Text:
        return static_cast<const TextContent*>(content)->text.c_str();
        break;
    case ContentType::File:
        return static_cast<const FileContent*>(content)->filename.c_str();
    case ContentType::Image:
        return "[图片] "+QString::fromStdString(static_cast<const ImageContent*>(content)->filename);
    case ContentType::Knock:
        return "窗口抖动";
    default:
        return "***";
        break;
    }
}

QString MainWindow::historyFilePath(const Fellow *fellow) const
{
    if (fellow == nullptr)
        return "";

    auto dirPath = QDir::home().filePath(".feiq_history");
    QDir().mkpath(dirPath);

    auto fileName = QString::fromStdString(fellow->getIp());
    fileName.replace("/", "_");
    fileName.replace(":", "_");
    return QDir(dirPath).filePath(fileName+".txt");
}

QString MainWindow::historyTextOf(const Content *content) const
{
    switch (content->type()) {
    case ContentType::Text:
        return QString::fromStdString(static_cast<const TextContent*>(content)->text);
    case ContentType::File:
    {
        auto file = static_cast<const FileContent*>(content);
        return QString("[文件] %1 (%2 bytes)").arg(QString::fromStdString(file->filename)).arg(file->size);
    }
    case ContentType::Knock:
        return "[窗口抖动]";
    case ContentType::Image:
    {
        auto image = static_cast<const ImageContent*>(content);
        return QString("[图片] %1 (%2 bytes)").arg(QString::fromStdString(image->filename)).arg(image->size);
    }
    default:
        return "[不支持的内容]";
    }
}

void MainWindow::appendHistory(const Fellow *fellow, const Content *content, bool mySelf, long long msSinceEpoch)
{
    auto path = historyFilePath(fellow);
    if (path.isEmpty())
        return;

    QFile file(path);
    if (!file.open(QIODevice::Append | QIODevice::Text))
        return;

    auto when = QDateTime::fromMSecsSinceEpoch(msSinceEpoch).toString("yyyy-MM-dd HH:mm:ss");
    auto name = mySelf ? QString("我") : QString::fromStdString(fellow->getName());
    auto text = historyTextOf(content);
    text.replace("\r\n", "\n");
    text.replace("\r", "\n");
    text.replace("\n", "\n    ");

    auto line = QString("[%1] %2: %3\n").arg(when, name, text);
    file.write(line.toUtf8());
}

void MainWindow::showHistory(const Fellow *fellow)
{
    if (fellow == nullptr)
        return;

    auto path = historyFilePath(fellow);
    QString text = "暂无历史记录";
    QFile file(path);
    if (file.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        text = QString::fromUtf8(file.readAll());
        if (text.trimmed().isEmpty())
            text = "暂无历史记录";
    }

    auto dlg = new QDialog(this);
    dlg->setAttribute(Qt::WA_DeleteOnClose);
    dlg->setWindowTitle("与 "+QString::fromStdString(fellow->getName())+" 的历史记录");
    dlg->resize(760, 520);

    auto layout = new QVBoxLayout(dlg);
    auto edit = new QTextEdit(dlg);
    edit->setReadOnly(true);
    edit->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(edit, &QTextEdit::customContextMenuRequested, [edit](const QPoint& pos) {
        RecvTextEdit::showReadOnlyContextMenu(edit, edit->viewport()->mapToGlobal(pos));
    });
    edit->setHtml(emojiTextToHtml(text));
    layout->addWidget(edit);

    auto buttons = new QDialogButtonBox(QDialogButtonBox::Close, dlg);
    connect(buttons, SIGNAL(rejected()), dlg, SLOT(close()));
    layout->addWidget(buttons);

    dlg->show();
}

UnshownMessage &MainWindow::addUnshownMessage(const Fellow *fellow, shared_ptr<ViewEvent> event)
{
    UnshownMessage msg;
    msg.event = event;
    mUnshownEvents[fellow].push_back(msg);
    return mUnshownEvents[fellow].back();
}

UnshownMessage* MainWindow::findUnshownMessage(int id)
{
    auto begin = mUnshownEvents.begin();
    auto end = mUnshownEvents.end();

    for (auto it = begin; it != end; it++)
    {
        for (auto& msg : it->second){
            if (msg.notifyId == id)
                return &msg;
        }
    }

    return nullptr;
}