#pragma once

#include "Visitor.h"

class BlobSerializer : public CActionVisitor
{
public:
	explicit BlobSerializer(CArchive &archive);

	void visit(CActionAddItem& item) override;
	void visit(CActionBackupItem& item) override;
	void visit(CActionBackupProjectionItem& item) override;
	void visit(CActionBackupXYItem& item) override;
	void visit(CActionChangeColorItem& item) override;
	void visit(CActionChangeLayerItem& item) override;
	void visit(CActionChangeNameItem& item) override;
	void visit(CActionComboItem& item) override;
	void visit(CActionCurveEdit& item) override;
	void visit(CActionCurveEditAddPoint& item) override;
	void visit(CActionCurveEditDeletePoint& item) override;
	void visit(CActionCurveReversalItem& item) override;
	void visit(CActionCutOutItem& item) override;
	void visit(CActionDeleteItem& item) override;
	void visit(CActionEmbellishItem& item) override;
	void visit(CActionExchangeXYItem& item) override;
	void visit(CActionLayerAddItem& item) override;
	void visit(CActionLayerDeleteItem& item) override;
	void visit(CActionLayerDragDropItem& item) override;
	void visit(CActionLayerRenameItem& item) override;
	void visit(CActionListItem & item) override;
	void visit(CActionMarkDeleteItem& item) override;
	void visit(CActionMirrorItem& item) override;
	void visit(CActionModifiedItem& item) override;
	void visit(CActionModifiedMeshItem& item) override;
	void visit(CActionModifiedMesh& item) override;
	void visit(CActionMoveItem& item) override;
	void visit(CActionOffsetItem& item) override;
	void visit(CActionParamReplaceItem& item) override;
	void visit(CActionReplaceColorItem& item) override;
	void visit(CActionReplaceNameItem& item) override;
	void visit(CActionReverseZItem& item) override;
	void visit(CActionScaleProperty& item) override;
	void visit(CActionSortItem& item) override;
	void visit(CAtionBackupEditCurveInName& item) override;
	void visit(CActionProjectionItem& item) override;
	void visit(CActionRotationItem& item) override;

private:
	/**
	 * 序列化数字数组
	 * 
	 * \param items
	 */
	template <typename T>
	void serialize(std::vector<T>& items)
	{
		// 写入数组长度
		m_archive << static_cast<uint64_t>(items.size());

		for (T item : items)
		{
			m_archive << item;
		}
	}

	template <typename T>
	void serializeElement(T* element)
	{
		if (element == nullptr)
		{
			m_archive << uint64_t(0);
			return;
		}

		CMemFile memFile;
		// 为什么多一次写入 CMemFile 操作而不直接写入 m_archive 对象? 我们想获取二进制内容的长度，其它地方同理
		CArchive ar(&memFile, CArchive::store);
		element->Serialize(ar, 2022);
		ar.Close();

		uint64_t count = memFile.GetLength();
		m_archive << count;

		std::vector<BYTE> buffer(count);
		memFile.SeekToBegin();
		memFile.Read(buffer.data(), static_cast<UINT>(count));

		m_archive.Write(buffer.data(), static_cast<UINT>(count));
	}

	template <typename T>
	void deserializeElement(T*& element)
	{
		uint64_t count = 0;
		m_archive >> count;

		if (count == 0)
		{
			element = nullptr;
			return;
		}

		std::vector<BYTE> buffer(count);
		m_archive.Read(buffer.data(), static_cast<UINT>(count));

		CMemFile memFile(buffer.data(), static_cast<UINT>(count));
		CArchive ar(&memFile, CArchive::load);
		element = new T();
		element->Serialize(ar, 2022);
		ar.Close();
	}

	/**
	 * 反序列化数字数组
	 * 
	 * \return 
	 */
	template <typename T>
	void deserialize(std::vector<T> &items)
	{
		items.clear();

		// 读取数组长度
		uint64_t count = 0;
		m_archive >> count;

		items.resize(count);
		for (size_t i = 0; i < items.size(); i++)
		{
			m_archive >> items[i];
		}
	}

	/**
	 * 序列化 COne 列表
	 * 
	 * \param ptrList
	 * \param owned 是否持有 COne 对象，如果持有，则完全序列化，否则只存储 id
	 */
	void serializeCOnes(CPtrList& ptrList, bool owned = false);

	/**
	 * 反序列化 COne 列表
	 * 
	 * \param ptrList 出参，COne 会追加到该列表中，注意，并不会清空 ptrList
	 * \param owned 是否持有 COne 对象，如果持有，则完全序列化，通过 id 再去拿 CXy 对象里面的指针
	 */
	void deserializeCOnes(CXy *pXy, CPtrList &ptrList, bool owned = false);

	/**
	 * 序列化 COne
	 * 
	 * \param pOne
	 */
	void serializeCOne(COne* pOne, bool owned = false);

	/**
	 * 反序列化 COne
	 * 
	 * \param pOne
	 */
	void deserializeCOne(CXy* pxy, COne*& pOne, bool owned = false);

	void serializeOwnedCOne(COne* pOne);

	void deserializeOwnedCOne(CXy* pXy, COne*& pOne);

	void serializeUnownedCOne(COne* pOne);

	void deserializeUnownedCOne(CXy* pXy, COne*& pOne);

	void serializeCLayer(CLayer* pLayer);

	void deserializeCLayer(CLayer*& pLayer);

	void serializeHowToViewCurve(CHowToViewCurve* viewCurve);

	void deserializeHowToViewCurve(CHowToViewCurve*& viewCurve);

	void serializeHowToViewPoint(CHowToViewPoint* viewCurve);

	void deserializeHowToViewPoint(CHowToViewPoint*& viewCurve);

	/**
	 * 序列化 Action 基类
	 * 
	 * \param action
	 */
	void serializeCAction(CAction& action);

	/** 
	 * 反序列化 Action 基类
	 */
	void deserializeCAction(CAction& action);

	/**
	 * 序列化基础的 CActionItem
	 * 
	 * \param item
	 */
	void serializeCActionItem(CActionItem& item);

	/**
	 * 反序列化基础的 CActionItem
	 * 
	 * \param item
	 */
	void deserializeCActionItem(CActionItem& item);

	void serializeCXy(CXy* pXy);

	void deserializeCXy(CXy*& pXy);

	void serializeDfPoint(dfPoint& point);
	void deserializeDfPoint(dfPoint& point);

	void serializeStdString(std::string& str);

	void deserializeStdString(std::string& str);

	void idsToPositions(CXy *pXy, const std::vector<int64_t>& ids, CPositionList& posList) const;
	std::vector<int64_t> positionsToIds(CXy *pXy, const CPositionList& positions) const;

	int64_t getIdByPosition(CXy* pXy, POSITION pos) const;

	int64_t getIdFromArchive();
	uint64_t getCountFromArchive();

	COne* lookupCOneById(CXy* pXy, int64_t id) const;
	std::vector<COne*> lookupCOneByIds(CXy* pXy, const std::vector<int64_t>& id) const;

	CLayer* lookupCLayerByPath(CXy* pXy, const CString& layerPath) const;
	std::vector<CLayer*> flatmapCLayer(CXy* pXy) const;
	void addLayersFromList(CLayerList* pLayerList, std::vector<CLayer*>& result) const;

	/**
	 * 恢复 parentClass
	 * 
	 * \param pXy
	 * \param pLayer
	 */
	void assignParentClass(CXy* pXy, CLayer* pLayer);

	CArchive &m_archive;
};

/**
 * 
 */
std::vector<char> SerializeAction(const CAction* action);

/**
 * 创建具体的子类对象
 *
 * \return
 */
CAction* DeserializeAction(CSigmaDoc *pDoc, const std::vector<char>& data);