#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;  // 已存在时返回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";
	}

	//locker.unlock();

	// 清空已保存的数据,由于前面连续插入数据，清空前先先加锁
	//QMutexLocker locker(&m_orderMutex);
	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));
		//if (order.isValid()) {
		//	
		//}
	}
}

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) {
		// 提取日期部分 (bigorders_20230515.json)
		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;
		}
	}
}