QTradeProgram/cleaned_source_code/Sqbase/qbigordermanager.cpp

#include "qbigordermanager.h"
#include <QMutexLocker>
#include <QCoreApplication>
#include <QDir>
#include <QDebug>
#include "qeventbus.h"
std::atomic<QBigOrderManager*> QBigOrderManager::s_instance(nullptr);
QMutex QBigOrderManager::s_mutex;
QBigOrderManager* QBigOrderManager::instance()
{
	QBigOrderManager* tmp = s_instance.load(std::memory_order_acquire);
	if (!tmp) {
		QMutexLocker locker(&s_mutex);
		tmp = s_instance.load(std::memory_order_relaxed);
		if (!tmp) {
			tmp = new QBigOrderManager();
			s_instance.store(tmp, std::memory_order_release);
			QObject::connect(qApp, &QCoreApplication::aboutToQuit, []() {
				QBigOrderManager::destroy();
			});
		}
	}
	return tmp;
}
void QBigOrderManager::destroy()
{
	QMutexLocker locker(&s_mutex);
	delete s_instance.load(std::memory_order_acquire);
	s_instance.store(nullptr, std::memory_order_release);
}
QBigOrderManager::QBigOrderManager(QObject *parent)
	: QObject(parent),
	m_autoSaveTimer(new QTimer(this))
{
	m_historyPath = QCoreApplication::applicationDirPath() + "/history";
	QDir().mkpath(m_historyPath);
	connect(m_autoSaveTimer, &QTimer::timeout, this, &QBigOrderManager::autoSave);
	setAutoSaveInterval(12);
	setAutoSave(true);
	m_autoSaveTimer->start();
}
QBigOrderManager::~QBigOrderManager()
{
	if (m_autoSaveEnabled) {
		saveToFile();
	}
}
bool QBigOrderManager::addBigOrder(const BigOrderInfo &order)
{
	QMutexLocker locker(&m_orderMutex);  
	QString strId = QString::number(order.orderId);
	if (m_bigOrderID.contains(strId)) {
		return false;  
	}
	auto newOrder = QSharedPointer<BigOrderInfo>::create(order);
	m_bigOrders.append(newOrder);
	m_bigOrderID.insert(strId);
	locker.unlock();  
	emit bigOrderAdded(order);
	emit markBigOrderSignal();
	QEventBus::instance()->publish(EventType::BIG_ORDER_DETECTED, 
								   QVariant::fromValue(order), 
								   "QBigOrderManager");
	return true;
}
QList<QSharedPointer<BigOrderInfo>> QBigOrderManager::getAllBigOrders() const
{
	QMutexLocker locker(&m_orderMutex);
	return m_bigOrders;
}
QList<QSharedPointer<BigOrderInfo>> QBigOrderManager::getBigOrdersByStock(const QString &stockCode) const
{
	QMutexLocker locker(&m_orderMutex);
	QList<QSharedPointer<BigOrderInfo>> result;
	for (const auto& order : m_bigOrders) {
		if (order->code == stockCode) {
			result.append(order);
		}
	}
	return result;
}
QList<QSharedPointer<BigOrderInfo>> QBigOrderManager::getBigOrdersByType(const QString &orderType) const
{
	QMutexLocker locker(&m_orderMutex);
	QList<QSharedPointer<BigOrderInfo>> result;
	for (const auto& order : m_bigOrders) {
		if (order->nBigOrderType == orderType) {
			result.append(order);
		}
	}
	return result;
}
void QBigOrderManager::setAutoSave(bool enabled)
{
	m_autoSaveEnabled = enabled;
	if (enabled) {
		m_autoSaveTimer->start();
	}
	else {
		m_autoSaveTimer->stop();
	}
}
void QBigOrderManager::setAutoSavePath(const QString &path)
{
	m_autoSavePath = path;
}
void QBigOrderManager::setAutoSaveInterval(int hours)
{
	m_autoSaveInterval = hours;
	m_autoSaveTimer->setInterval(hours * 60 * 60 * 1000);
}
void QBigOrderManager::saveToFile()
{
	if (m_historyPath.isEmpty()) {
		qWarning() << "History path not set";
		return;
	}
	QDir historyDir(m_historyPath);
	if (!historyDir.exists()) {
		historyDir.mkpath(".");
	}
	QDate today = QDate::currentDate();
	QString filePath = historyDir.filePath(QString("bigorders_%1.json").arg(today.toString("yyyyMMdd")));
	QFile file(filePath);
	if (!file.open(QIODevice::Append | QIODevice::Text)) {
		qWarning() << "Failed to open file for writing:" << filePath;
		return;
	}
	QTextStream out(&file);
	out.setCodec("UTF-8");
	QMutexLocker locker(&m_orderMutex);
	for (const auto& order : m_bigOrders) {
		out << QJsonDocument(order->toJson()).toJson(QJsonDocument::Compact) << "\n";
	}
	m_bigOrders.clear();
	m_bigOrderID.clear();
	locker.unlock();
	file.close();
}
void QBigOrderManager::loadFromFile()
{
	if (m_autoSavePath.isEmpty() || !QFile::exists(m_autoSavePath)) {
		return;
	}
	QFile file(m_autoSavePath);
	if (!file.open(QIODevice::ReadOnly)) {
		qWarning() << "Failed to open file for reading:" << m_autoSavePath;
		return;
	}
	QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
	file.close();
	if (doc.isNull() || !doc.isArray()) {
		qWarning() << "Invalid JSON data in file:" << m_autoSavePath;
		return;
	}
	QMutexLocker locker(&m_orderMutex);
	m_bigOrders.clear();
	m_bigOrderID.clear();
	QJsonArray jsonArray = doc.array();
	for (const auto& jsonValue : jsonArray) {
		BigOrderInfo order = BigOrderInfo::fromJson(jsonValue.toObject());
		m_bigOrders.append(QSharedPointer<BigOrderInfo>::create(order));
	}
}
void QBigOrderManager::autoSave()
{
	if (m_autoSaveEnabled) {
		saveToFile();
		emit saveOverRefreshView();	
	}
}
void QBigOrderManager::cleanupOldData(int maxDays)
{
	QDir historyDir(m_historyPath);
	if (!historyDir.exists()) return;
	QDate currentDate = QDate::currentDate();
	QStringList files = historyDir.entryList(QStringList() << "bigorders_*.json", QDir::Files);
	for (const QString &fileName : files) {
		QString dateStr = fileName.mid(10, 8);
		QDate fileDate = QDate::fromString(dateStr, "yyyyMMdd");
		if (fileDate.isValid() && fileDate.daysTo(currentDate) > maxDays) {
			QString filePath = historyDir.filePath(fileName);
			QFile::remove(filePath);
			qDebug() << "Removed old data file:" << filePath;
		}
	}
}