#include "stdafx.h"
#include "BlobSerializer.h"
#include "ClassFactory.h"
#include "DrawOperator/XySerializerHelper.h"
#include "SigmaDoc.h"
#include "SigmaStore.h"
#include "UndoManager/UndoManager.h"
#include "Util.h"
#include "../DrawOperator/Util.h"
#include "StorageFactory.h"
#include "AsyncWorker.h"
#include <chrono>
#include <filesystem>
#include <optional>
#include <mutex>

/**
 * @brief CSigmaStore::Impl 类的实现
 */
class CSigmaStore::Impl
{
public:
	Impl(std::shared_ptr<IActionStorage> storage)
		: m_storage(storage)
	{
	}

	void SetActions(CSigmaDoc* pDoc)
	{
		const std::deque<CAction*>& redoStack = pDoc->GetActionManager()->GetRedoStack();

		std::vector<ActionRecord> records = m_asyncWorker.postTask([=]()
			{
				return m_storage->RetrieveAllActionRecords(CStringToUtf8String(pDoc->m_FileName));
			}).get();

		for (const auto& record : records)
		{
			CAction* pAction = DeserializeAction(pDoc, record.data);
			if (pAction != nullptr)
			{
				if (CActionItem* pActionItem = dynamic_cast<CActionItem*>(pAction))
				{
					const_cast<std::deque<CAction*>&>(redoStack).push_front(pAction);
					pDoc->Redo();
				}
			}
		}
	}

	/**
     * @brief 保存操作记录
     * @param actions 操作记录向量
     * @param path 文件路径
     */
	void SaveActions(std::vector<ActionRecord>& actions, const CString& path)
	{
		if (!m_storage)
        {
            throw std::runtime_error("m_storage is nullptr");
        }

		if (actions.empty())
		{
			return;
		}
		
		std::string filePath = CStringToUtf8String(path);

		CacheActions(path, actions);

		m_asyncWorker.postTask([this, storage = m_storage, filePath, movedActions = std::move(actions)]()
			{
				for (auto& record : movedActions)
				{
					if (!storage->ExistsActionRecord(filePath, record.uuid))
					{
						storage->AddActionRecord(filePath, record);
					}
				}
			});
	}

	/**
     * @brief 根据需要保存文件数据
     * @param pDoc 文档指针
     * @param path 文件路径
     */
	void SaveFileDataIfNeed(CSigmaDoc* pDoc, const CString& path)
	{
		if (!m_storage)
        {
            throw std::runtime_error("m_storage is nullptr");
        }

		std::string filePath = CStringToUtf8String(path);
		if (!m_storage->ExistsFileData(filePath))
		{
			auto rawData = CXySerializerHelper::SerializeCXy(pDoc->m_pXy);
			auto pFileData = std::make_shared<FileData>(
				-1, filePath, reinterpret_cast<std::vector<char>&>(rawData), FormatTime(std::chrono::system_clock::now())
			);

			m_asyncWorker.postTask([this, filePath, pFileData]()
				{
					m_storage->InsertFileData(filePath, *pFileData);
				});
		}
	}

    /**
     * @brief 获取文档的操作记录
     * @param pDoc 文档指针
     * @return 操作记录向量
     */
	std::vector<ActionRecord> GetActionRecords(const CSigmaDoc* pDoc)
	{
		if (!m_storage)
        {
            throw std::runtime_error("m_storage is nullptr");
        }

		std::vector<ActionRecord> result;
		auto actionManager = const_cast<CSigmaDoc*>(pDoc)->GetActionManager();

		if (actionManager)
		{
			std::vector<CAction*> actions;
			const auto& undoStack = actionManager->GetUndoStack();
			for (auto* action : undoStack)
			{
				actions.push_back(action);
			}

			const auto& redoStack = actionManager->GetRedoStack();
			for (auto it = redoStack.rbegin(); it != redoStack.rend(); ++it)
			{
				actions.push_back(*it);
			}

			CSplitPath sp("");
			CString path = sp.GetAbsolutePath(pDoc->m_FileName);

			for (auto* action : actions)
			{
				if (InCache(path, action->GetUUID()))
				{
					continue;
				}

				result.push_back({
					-1,
					action->GetUUID(),
					action->GetActionName(),
					"",
					SerializeAction(action),
					FormatTime(action->GetTimePoint()),
					FormatTime(std::chrono::system_clock::now())
					});
			}
		}

		return result;
	}

    /**
     * @brief 获取操作记录数量
     * @param path 文件路径
     * @return 操作记录数量
     */
	int ActionRecordCount(const CString& path)
	{
		if (!m_storage)
        {
            throw std::runtime_error("m_storage is nullptr");
        }

		return m_asyncWorker.postTask([=]()
			{
				std::string u8path = CStringToUtf8String(path);
				return m_storage->ActionRecordCount(u8path);
			}).get();
	}

    /**
     * @brief 检索文件数据
     * @param filePath 文件路径
     * @return 文件数据（可选）
     */
	std::optional<FileData> RetrieveFileData(const CString& filePath)
	{
		if (!m_storage)
        {
            throw std::runtime_error("m_storage is nullptr");
        }

		return m_asyncWorker.postTask([=]()
			{
				std::string u8path = CStringToUtf8String(filePath);
				return m_storage->RetrieveFileData(u8path);
			}).get();
	}

    /**
     * @brief 清除指定路径的备份
     * @param path 文件路径
     */
	void Clear(const CString& path)
	{
		if (!m_storage)
        {
            throw std::runtime_error("m_storage is nullptr");
        }

		m_asyncWorker.postTask([=]()
			{
				std::string u8path = CStringToUtf8String(path);
				m_storage->ClearBackup(u8path);
			}).wait();

		ClearActionCache(path);
	}

private:
	void ClearActionCache(const CString& path)
	{
		auto it = m_actionCache.find(path);
		if (it != m_actionCache.end())
		{
			m_actionCache.erase(it);
		}
	}

	void CacheActions(const CString& path, const std::vector<ActionRecord>& actions)
	{
		std::set<std::string> set;
		for (const ActionRecord& action : actions)
		{
			set.insert(action.uuid);
		}
		m_actionCache[path] = std::move(set);
	}

	bool InCache(const CString& path, const std::string& uuid) const
	{
		auto it = m_actionCache.find(path);
		if (it == m_actionCache.end())
		{
			return false;
		}

		return it->second.find(uuid) != it->second.end();
	}

	std::shared_ptr<IActionStorage> m_storage;
	AsyncWorker m_asyncWorker;
	std::unordered_map<CString, std::set<std::string>, CStringHash> m_actionCache;
};


CSigmaStore::CSigmaStore(std::shared_ptr<IActionStorage> storage)
	: m_impl(std::make_unique<CSigmaStore::Impl>(storage))
{
}

CSigmaStore::~CSigmaStore()
{
}

bool CSigmaStore::Exist(const CString& path)
{
	try
	{
		return m_impl->ActionRecordCount(path) > 0;
	}
	catch (std::runtime_error& e)
	{
		TRACE("Exist %s failed: %s\n", path, e.what());
	}

	return false;
}

bool CSigmaStore::Load(CSigmaDoc* pDoc, const CString& path)
{
	try
	{
		auto fileDataOpt = m_impl->RetrieveFileData(path);
		if (!fileDataOpt.has_value())
		{
			return false;
		}

		auto& fileData = fileDataOpt.value();

		pDoc->m_pXy = CXySerializerHelper::DeserializeCXy(reinterpret_cast<std::vector<BYTE>&>(fileData.data)).release();
		pDoc->m_FileName = Utf8StringToCString(fileData.filepath);
		m_impl->SetActions(pDoc);

		return pDoc;
	}
	catch (const std::runtime_error &e)
	{
		TRACE("Load %s failed: %s\n", path, e.what());
		return false;
	}
	catch (CException* e)
	{
		TCHAR   errorMessage[512]{ 0 };
		UINT    nHelpContext = 0;

		e->GetErrorMessage(errorMessage, sizeof(errorMessage), &nHelpContext);
		TRACE("Load %s failed: %s\n", path, errorMessage);
	}
	catch (...)
	{
		TRACE("Load %s failed: Unkown");
		return false;
	}

	return true;
}

bool CSigmaStore::Save(CSigmaDoc* pDoc)
{
	CSplitPath sp("");
	CString path = sp.GetAbsolutePath(pDoc->m_FileName);

	try
	{
		m_impl->SaveFileDataIfNeed(pDoc, path);
		m_impl->SaveActions(m_impl->GetActionRecords(pDoc), path);

		return true;
	}
	catch (const std::runtime_error &e)
	{
		TRACE("Save %s failed: %s\n", pDoc->m_FileName, e.what());
		return false;
	}
	catch (CException* e)
	{
		TCHAR   errorMessage[512]{ 0 };
		UINT    nHelpContext = 0;

		e->GetErrorMessage(errorMessage, sizeof(errorMessage), &nHelpContext);
		TRACE("Save %s failed: %s\n", path, errorMessage);
	}
	catch (...)
	{
		TRACE("Save %s failed: Unkown");
		return false;
	}
}

void CSigmaStore::Clear(const CString& path)
{
	try
	{
		m_impl->Clear(path);
	}
	catch (const std::runtime_error& e)
	{
		TRACE("Clear %s failed: %s\n", path, e.what());
	}
}