#pragma once

#ifdef EARTHWORM_EXPORT
#define DLLIMPEXP __declspec(dllexport)
#else
#define DLLIMPEXP __declspec(dllimport)
#endif

#include "dbtable.h"
#include "dbTableStyle.h "
#include <vector>

class DLLIMPEXP MKTABLE
{
public:
	typedef std::vector<CString> RowData;
	typedef std::vector<RowData> TableData;

public:
	// 查找 AcDbTableStyle ,不存在则创建默认样式
	static AcDbObjectId getTableStyle(LPCTSTR pszTSName);

	// 查找 AcDbTextStyleTableRecord ,不存在则创建默认样式
	static AcDbObjectId getTextStyle(LPCTSTR pszTSName);

	// 查找 AcDbLinetypeTableRecord ,不存在则创建默认样式
	static AcDbObjectId getLinetype(LPCTSTR pszLinetypeName);

	// 取 listCtrl 中 idxs 指定的列，按顺序提取数据
	static bool extractDatasFromListCtrl(CListCtrl &listCtrl
		, std::vector<TableData> &outDatas
		, RowData &headers
		, const std::vector<int> &idxs
		, const int &maxRow);

	// 通过界面选择 listCtrl 中的列，并返回所选列的索引，包含顺序
	static void selectColumnsFromListCtrl(CHeaderCtrl &headerCtrl
		, std::vector<int> &idxs
		, double &dPScale
		, CString &sTemplate);

	// 自动根据表格内容调整表格大小
	static void autoSizeTable(AcDbTable *pTable);

	// 获得表格模板列表
	static void getTableTemplateList(std::vector<CString> &outTemplates);

public:
	// 针对数据保存在CListCtrl中的表格，生成 AcDbTable
	static bool makeTable(CListCtrl &listCtrl, LPCTSTR pszTitle, const int &maxRow);
};


#define _DEFINE_(type, name)\
void set##name(const type &val)\
{\
	m_##name = val;\
	m_bUse##name = true;\
}\
type m_##name;\
bool m_bUse##name

#define _DEFINE_LINETYPE_PROPERTY_(name, linetype)\
void set##name(const CellGridLineTypeProperty &val)\
{\
	m_##name = val;\
	m_bUse##name = true;\
}\
CellGridLineTypeProperty m_##name;\
bool m_bUse##name

#define APPLY_MARGIN(v)\
if (m_bUse##v)\
{\
	pTS->setMargin(AcDb::kCellMargin##v, m_##v*dPScale, pszCellStyle);\
}

#define APPLY_GRIDLINE_PROPERTY(v)\
if (m_bUse##v)\
{\
	pTb->setGrid##v(nRow, nCol, m_type, m_##v);\
}

#define APPLY_GRIDLINE_TYPE(v)\
	for (size_t i = 0; i < m_##v.size(); ++i)\
	{\
		m_##v[i].apply2Table(pTb);\
	}\

#define APPLY_CELL_STYLE(v)\
if (m_bUse##v)\
{\
	pTS->set##v(m_##v, m_sName);\
}

class MKTABLE;
namespace TABLE
{
	struct CellMergeRange
	{
		int m_maxRow, m_minRow, m_maxCol, m_minCol;

		CellMergeRange(): m_maxRow(-1), m_minRow(-1), m_maxCol(-1), m_minCol(-1) {}

		CellMergeRange(const CellMergeRange &mg): m_maxRow(mg.m_maxRow)
			, m_minRow(mg.m_minRow)
			, m_maxCol(mg.m_maxCol)
			, m_minCol(mg.m_minCol) { }

		CellMergeRange(const int &minRow
			, const int &maxRow
			, const int &minCol
			, const int &maxCol)
			: m_maxRow(maxRow)
			, m_minRow(minRow)
			, m_maxCol(maxCol)
			, m_minCol(minCol) { }

		CellMergeRange& operator=(const CellMergeRange &mg)
		{
			if (this != &mg)
			{
				m_maxRow = mg.m_maxRow;
				m_minRow = mg.m_minRow;
				m_maxCol = mg.m_maxCol;
				m_minCol = mg.m_minCol;
			}
			return *this;
		}

		bool vaild(const int &nRow, const int &nCol)
		{
			// 负数表示从后往前计数，先计算正确位置
			if (m_minRow < 0) m_minRow += nRow;
			if (m_maxRow < 0) m_maxRow += nRow;
			if (m_minCol < 0) m_minCol += nCol;
			if (m_maxCol < 0) m_maxCol += nCol;

			// 边缘保护调整
			// 最小行/列 小于0，调整为0，即第一行
			if (m_minRow < 0) m_minRow = 0;
			if (m_minCol < 0) m_minCol = 0;
			// 最大行/列 大于总行/列数，调整为总行/列数-1，即最后一行
			if (m_maxRow >= nRow) m_maxRow = nRow - 1;
			if (m_maxCol >= nRow) m_maxCol = nCol - 1;

			// 最小行/列大于总行/列数
			if (m_minRow > nRow || m_minCol > nCol) return false;

			// 最大行/列 小于0
			if (m_maxRow < 0 || m_maxCol < 0) return false;

			// 最小行/列 大于 最大行/列
			if (m_minRow > m_maxRow || m_minCol > m_maxCol) return false;

			return true;
		}

		void apply2Table(AcDbTable *pTb)
		{
			if (vaild(pTb->numRows(), pTb->numColumns()))
				pTb->mergeCells(m_minRow, m_maxRow, m_minCol, m_maxCol);
		}
	};
	typedef std::vector<CellMergeRange> CellMerges;

	struct CellMargin
	{
		_DEFINE_(double, Left);
		_DEFINE_(double, Right);
		_DEFINE_(double, Top);
		_DEFINE_(double, Bottom);
		_DEFINE_(double, HorzSpacing);
		_DEFINE_(double, VertSpacing);

		CellMargin(): m_bUseLeft(false)
			, m_bUseRight(false)
			, m_bUseTop(false)
			, m_bUseBottom(false)
			, m_bUseHorzSpacing(false)
			, m_bUseVertSpacing(false) { }
		void apply2TableStyle(AcDbTableStyle *pTS, LPCTSTR pszCellStyle, const double &dPScale)
		{
			APPLY_MARGIN(Left);
			APPLY_MARGIN(Right);
			APPLY_MARGIN(Top);
			APPLY_MARGIN(Bottom);
			APPLY_MARGIN(HorzSpacing);
			APPLY_MARGIN(VertSpacing);
		}
	};

	struct GridLineTypeProperty
	{
		int m_minRow, m_minCol;
		int m_maxRow, m_maxCol;
		double m_dPScale;
		AcDb::GridLineType m_type;
		_DEFINE_(AcDb::GridLineStyle, LineStyle);
		_DEFINE_(AcDb::LineWeight, LineWeight);
		_DEFINE_(CString, Linetype);
		_DEFINE_(int, Color);
		_DEFINE_(AcDb::Visibility, Visibility);
		_DEFINE_(double, DoubleLineSpacing);

		GridLineTypeProperty(AcDb::GridLineType type
			, const int &minRow
			, const int &maxRow
			, const int &minCol
			, const int &maxCol
			, const double &dps )
			: m_type(type)
			, m_dPScale(dps)
			, m_minRow(minRow)
			, m_maxRow(maxRow)
			, m_minCol(minCol)
			, m_maxCol(maxCol)
			, m_bUseLinetype(false)
			, m_bUseColor(false)
			, m_bUseLineStyle(false)
			, m_bUseLineWeight(false)
			, m_bUseVisibility(false)
			, m_bUseDoubleLineSpacing(false) { }

		void apply2Table(AcDbTable *pTb) const
		{
			CellMergeRange tempRange(m_minRow, m_maxRow, m_minCol, m_maxCol);

			// 先调整范围合法性
			if (!tempRange.vaild(pTb->numRows(), pTb->numColumns())) return;

			int minRow = tempRange.m_minRow;
			int maxRow = tempRange.m_maxRow;
			int minCol = tempRange.m_minCol;
			int maxCol = tempRange.m_maxCol;

			for (int nRow(minRow); nRow <= maxRow; ++nRow)
			{
				for (int nCol(minCol); nCol <= maxCol; ++nCol)
				{
					APPLY_GRIDLINE_PROPERTY(LineStyle);
					APPLY_GRIDLINE_PROPERTY(LineWeight);
					APPLY_GRIDLINE_PROPERTY(Visibility);

					if (m_bUseDoubleLineSpacing)
					{
						pTb->setGridDoubleLineSpacing(nRow
							, nCol
							, m_type
							, m_DoubleLineSpacing * m_dPScale);
					}

					if (m_bUseColor)
					{
						AcCmColor clr;
						clr.setColorIndex(m_Color);
						pTb->setGridColor(m_type, nRow, nCol, clr);
					}

					if (m_bUseLinetype)
					{
						AcDbObjectId id(MKTABLE::getTextStyle(m_Linetype));
						if (id.isValid())
							pTb->setGridLinetype(nRow, nCol, m_type, id);
					}
				}
			}
		}
	};
	typedef std::vector<GridLineTypeProperty> GridLineTypePropertys;

	struct GridLineType
	{
		_DEFINE_(GridLineTypePropertys, HorzTop);
		_DEFINE_(GridLineTypePropertys, HorzInside);
		_DEFINE_(GridLineTypePropertys, HorzBottom);
		_DEFINE_(GridLineTypePropertys, VertLeft);
		_DEFINE_(GridLineTypePropertys, VertInside);
		_DEFINE_(GridLineTypePropertys, VertRight);
		_DEFINE_(GridLineTypePropertys, HorzGridLineTypes);
		_DEFINE_(GridLineTypePropertys, VertGridLineTypes);
		_DEFINE_(GridLineTypePropertys, OuterGridLineTypes);
		_DEFINE_(GridLineTypePropertys, InnerGridLineTypes);
		_DEFINE_(GridLineTypePropertys, AllGridLineTypes);
		GridLineType(){ }

		void apply2Table(AcDbTable *pTb) const
		{
			APPLY_GRIDLINE_TYPE(HorzTop);
			APPLY_GRIDLINE_TYPE(HorzInside);
			APPLY_GRIDLINE_TYPE(HorzBottom);
			APPLY_GRIDLINE_TYPE(VertLeft);
			APPLY_GRIDLINE_TYPE(VertInside);
			APPLY_GRIDLINE_TYPE(VertRight);
			APPLY_GRIDLINE_TYPE(HorzGridLineTypes);
			APPLY_GRIDLINE_TYPE(VertGridLineTypes);
			APPLY_GRIDLINE_TYPE(OuterGridLineTypes);
			APPLY_GRIDLINE_TYPE(InnerGridLineTypes);
			APPLY_GRIDLINE_TYPE(AllGridLineTypes);
		}
	};

	struct CellStyle
	{
		CString	m_sName;

		_DEFINE_(CString, TextStyle);
		_DEFINE_(double, TextHeight);
		_DEFINE_(double, Rotation);
		_DEFINE_(int, Color);
		_DEFINE_(int, BackgroundColor);
		_DEFINE_(AcDb::CellAlignment, Alignment);
		_DEFINE_(CellMargin, Margin);
		_DEFINE_(bool, enableMergeAll);

		CellStyle(): m_sName(_T(""))
			, m_bUseColor(false)
			, m_bUseBackgroundColor(false)
			, m_bUseTextStyle(false)
			, m_bUseTextHeight(false)
			, m_bUseRotation(false)
			, m_bUseMargin(false)
			, m_bUseenableMergeAll(false)
			, m_bUseAlignment(false) { }

		void apply2CellStyle(AcDbTableStyle *pTS, const double &dPScale)
		{
			AcStringArray cellnames;
			pTS->getCellStyles(cellnames);
			if (cellnames.find((LPCTSTR)m_sName) == -1)
			{
				if (pTS->createCellStyle(m_sName) != Acad::eOk)
					return;
			}

			APPLY_CELL_STYLE(Alignment);
			APPLY_CELL_STYLE(Rotation);

			if (m_bUseTextHeight)
			{
				pTS->setTextHeight(m_TextHeight * dPScale, m_sName);
			}

			if (m_bUseColor)
			{
				AcCmColor clr;
				clr.setColorIndex(m_Color);
				pTS->setColor(clr, m_sName);
			}

			if (m_bUseBackgroundColor)
			{
				AcCmColor clr;
				clr.setColorIndex(m_BackgroundColor);
				pTS->setBackgroundColor(clr, m_sName);
			}

			if (m_bUseTextStyle)
			{
				AcDbObjectId tsId = MKTABLE::getTextStyle(m_TextStyle);
				if (tsId.isValid())
					pTS->setTextStyle(tsId, m_sName);
			}

			if (m_bUseenableMergeAll)
				pTS->enableMergeAll(m_enableMergeAll, m_sName);

			if (m_bUseMargin)
			{
				m_Margin.apply2TableStyle(pTS, m_sName, dPScale);
			}
		}
	};
	typedef std::map<CString, CellStyle> CellStyles;

	struct Cell
	{
		int row;
		int col;
		CString text;
		CString style;
		void apply2Table(AcDbTable *pTb) const
		{
			if (!pTb) return;
			pTb->setTextString(row, col, text);
			if (!style.IsEmpty())
				pTb->setCellStyle(row, col, style);
		}
	};
	typedef std::vector<Cell> Cells, CellRowData;
	typedef std::vector<Cells> CellTableData;

	struct TableStyle
	{
		CString m_sName;
		std::map<CString, CellStyle> m_cellStyles;
	};
	typedef std::map<CString, TableStyle> TableStyles;

	struct DataContent
	{
		// 默认单元格样式，一定要设置，只能是_TITLE,_DATA,_HEADER
		// 因为这三种样式是 AcDbTableStyle 自带并且无法删除的
		CString m_defCellStyle;

		CellTableData m_tableData;

		DataContent(LPCTSTR	def): m_defCellStyle(def) {}
		
	};
	typedef std::map<CString, DataContent> DataContents;
}