#pragma once
#include "stdafx.h"
#include "ElementRangeDB.h"
#include "ElementRangeTable.h"

namespace OTSSQLITE
{
	using namespace OTSDATA;
	CElementRangeDB::CElementRangeDB(CDBStoreBasePtr a_datastore)
	{
		m_tableInfo.reset(new CElementRangeTable());
		myDB = CreateNewSQLiteDB(a_datastore,m_tableInfo);
	}

	CElementRangeDB::~CElementRangeDB()
	{
	}

	CElementRangeList CElementRangeDB::GetElementRangeListById(const long a_nSTDId, const long a_nElementSize)
	{
		CElementRangeList listElementRange;

		if (!m_listSTDItem.empty())
		{
			for (auto& pSTDItem : m_listSTDItem)
			{
				if (pSTDItem->GetSTDId() == (DWORD)a_nSTDId && pSTDItem->GetElementRange() == a_nElementSize)
				{
					listElementRange = pSTDItem->GetElementRangeList();
				}
			}
		}
		else
		{
			// read element list
			for (int i = 0; i < a_nElementSize; i++)
			{
				auto tableQuery = GetQueryById(a_nSTDId, i, a_nElementSize);
				ASSERT(tableQuery);
				if (!tableQuery)
				{
					return listElementRange;
				}

				CSTDItemPtr pItem = ReadSTDItem(tableQuery);
				ASSERT(pItem);
				if (!pItem)
				{
					return listElementRange;
				}

				CElementRangeList listElement = pItem->GetElementRangeList();
				CElementRangePtr pElement = CElementRangePtr(new CElementRange(*listElement[0].get()));
				listElementRange.push_back(pElement);
			}

		}

		return listElementRange;
	}

	CSTDItemsList& CElementRangeDB::GetSTDItemList(const BOOL a_bForce/* = FALSE*/)
	{
		if (a_bForce)
		{
			m_listSTDItem.clear();
		}

		if (m_listSTDItem.size() == 0)
		{
			ReadSTDItemList();
		}

		return m_listSTDItem;
	}
	
	CDBTableBasePtr CElementRangeDB::GetTableInfo()
	{
		/*if (!m_tableInfo)
		{
			m_tableInfo.reset(new CElementRangeTable);
		}*/

		return m_tableInfo;
	}

	BOOL CElementRangeDB::Init(const BOOL a_bClean /*= FALSE*/)
	{
		return myDB->Init(a_bClean);
	}

	BOOL CElementRangeDB::CreateTable(const BOOL a_bForce /*= FALSE*/)
	{
		return myDB->CreateTable(a_bForce);
	}

	BOOL CElementRangeDB::DeleteTable()
	{
		return myDB->DeleteTable();
	}

	BOOL CElementRangeDB::RemoveAllRows()
	{
		return myDB->RemoveAllRows();
	}

	BOOL CElementRangeDB::IsDBExist()
	{
		return myDB->IsDBExist();
	}

	OTSSQLITE::CDBStoreBasePtr CElementRangeDB::GetDatastore()
	{
		return myDB->GetDatastore();
	}

	OTSSQLITE::CDBQueryBasePtr CElementRangeDB::GetTableQuery(LPCTSTR a_sOrderColumnName /*= nullptr*/)
	{
		return myDB->GetTableQuery(a_sOrderColumnName);
	}

	BOOL CElementRangeDB::ReadSTDItemList()
	{
		auto tableInfoPtr = GetTableInfo();
		ASSERT(tableInfoPtr);
		if (!tableInfoPtr)
		{
			return FALSE;
		}

		auto query = GetTableQuery();
		ASSERT(query);
		if (!query)
		{
			return FALSE;
		}

		m_listSTDItem = ReadSTDItemList(query);

		return TRUE;
	}

	CSTDItemsList CElementRangeDB::ReadSTDItemList(CDBQueryBasePtr a_query)
	{
		CSTDItemsList listSTDItem;

		int nRowId = 0;
		int nWrongItems = 0;
		while (!a_query->IsEOF())
		{
			auto STDItem = ReadSTDItem(a_query);	//current x-ray point		

			if (!STDItem)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Read xray point info item failed: row id: %d"), nRowId);
				nWrongItems++;
			}
			else
			{
				if (!listSTDItem.empty())
				{
					int nSTDId = STDItem->GetSTDId();
					CElementRangeList listElementNew = STDItem->GetElementRangeList();

					int nIndex = 0;

					for (auto Item : listSTDItem)
					{
						listSTDItem.erase(listSTDItem.begin() + nIndex);
						if (Item->GetSTDId() == nSTDId)
						{
							CElementRangeList listElementOld = Item->GetElementRangeList();

							for (auto pElement : listElementNew)
							{
								listElementOld.push_back(CElementRangePtr(new CElementRange(*pElement.get())));
							}

							STDItem->SetElementRangeList(listElementOld);

							break;
						}
						nIndex++;
					}

				}

				listSTDItem.push_back(STDItem);
			}

			a_query->NextRow();
			nRowId++;
		}

		return listSTDItem;
	}

	CSTDItemPtr CElementRangeDB::ReadSTDItem(CDBQueryBasePtr a_query)
	{
		int nCol;
		CSTDItemPtr pSTDItem(new CSTDItem());
			
		int nRangeNum;
		nCol = (int)CElementRangeTable::ColumnID::N_RANGE_NUM - (int)CElementRangeTable::ColumnID::MIN;
		nRangeNum = a_query->GetColIntValue(nCol, -1);
		pSTDItem->SetElementRange(nRangeNum);

		int nSTDIdNow;
		nCol = (int)CElementRangeTable::ColumnID::N_STD_ID - (int)CElementRangeTable::ColumnID::MIN;
		nSTDIdNow = a_query->GetColIntValue(nCol, -1);
		pSTDItem->SetSTDId(nSTDIdNow);

		CElementRangePtr pElementRange = CElementRangePtr(new CElementRange());
		
		int nRangeStart;
		nCol = (int)CElementRangeTable::ColumnID::N_RANGE_START - (int)CElementRangeTable::ColumnID::MIN;
		nRangeStart = a_query->GetColIntValue(nCol, -1);

		int nRangeEnd;
		nCol = (int)CElementRangeTable::ColumnID::N_RANGE_END - (int)CElementRangeTable::ColumnID::MIN;
		nRangeEnd = a_query->GetColIntValue(nCol, -1);

		CIntRangePtr pIntRange = CIntRangePtr(new CIntRange());
		pIntRange->SetStart(nRangeStart);
		pIntRange->SetEnd(nRangeEnd);
		pElementRange->SetRange(pIntRange);

		CElementPtr pElement = CElementPtr(new CElement());

		int nAtomNum;
		nCol = (int)CElementRangeTable::ColumnID::N_ATOM_NUM - (int)CElementRangeTable::ColumnID::MIN;
		nAtomNum = a_query->GetColIntValue(nCol, -1);
		pElement->SetAtomNum(nAtomNum);		

		double dPercent;
		nCol = (int)CElementRangeTable::ColumnID::F_PERCENTAGE - (int)CElementRangeTable::ColumnID::MIN;
		dPercent = a_query->GetColFloatValue(nCol, -1);
		pElement->SetPercentage(dPercent);

		pElementRange->SetElement(pElement);

		CElementRangeList listElementRange;
		listElementRange.push_back(pElementRange);

		a_query->NextRow();

		int nSTDIdNew;

		int nRowId = 0;
		while (!a_query->IsEOF())
		{
			nCol = (int)CElementRangeTable::ColumnID::N_STD_ID - (int)CElementRangeTable::ColumnID::MIN;
			nSTDIdNew = a_query->GetColIntValue(nCol, -1);

			if (nSTDIdNew == nSTDIdNow)
			{
				CElementRangePtr pElementRange = CElementRangePtr(new CElementRange());

				int nElementIndex;
				nCol = (int)CElementRangeTable::ColumnID::N_RANGE_ID - (int)CElementRangeTable::ColumnID::MIN;
				nElementIndex = a_query->GetColIntValue(nCol, -1);

				int nRangeStart;
				nCol = (int)CElementRangeTable::ColumnID::N_RANGE_START - (int)CElementRangeTable::ColumnID::MIN;
				nRangeStart = a_query->GetColIntValue(nCol, -1);

				int nRangeEnd;
				nCol = (int)CElementRangeTable::ColumnID::N_RANGE_END - (int)CElementRangeTable::ColumnID::MIN;
				nRangeEnd = a_query->GetColIntValue(nCol, -1);

				CIntRangePtr pIntRange = CIntRangePtr(new CIntRange());
				pIntRange->SetStart(nRangeStart);
				pIntRange->SetEnd(nRangeEnd);
				pElementRange->SetRange(pIntRange);

				CElementPtr pElement = CElementPtr(new CElement());

				int nAtomNum;
				nCol = (int)CElementRangeTable::ColumnID::N_ATOM_NUM - (int)CElementRangeTable::ColumnID::MIN;
				nAtomNum = a_query->GetColIntValue(nCol, -1);
				pElement->SetAtomNum(nAtomNum);

				double dPercent;
				nCol = (int)CElementRangeTable::ColumnID::F_PERCENTAGE - (int)CElementRangeTable::ColumnID::MIN;
				dPercent = a_query->GetColFloatValue(nCol, -1);
				pElement->SetPercentage(dPercent);

				pElementRange->SetElement(pElement);
			
				listElementRange.push_back(pElementRange);

				if (nElementIndex == nRangeNum - 1)
				{
					break;
				}
			}
			else
			{
				continue;
			}

			a_query->NextRow();
			nRowId++;
		}

		pSTDItem->SetElementRangeList(listElementRange);

		return pSTDItem;
	}

	CDBQueryBasePtr CElementRangeDB::GetQueryById(const long a_nSTDId, const long a_nElementId, const long a_nElementNum)
	{
		CDBQueryBasePtr query;
		auto datastorePtr = GetDatastore();
		ASSERT(datastorePtr);
		if (!datastorePtr)
		{
			return query;
		}

		auto tableInfoPtr = GetTableInfo();
		ASSERT(tableInfoPtr);
		if (!tableInfoPtr)
		{
			return query;
		}

		CString sSTDIdColumnName = tableInfoPtr->GetColumnName((int)CElementRangeTable::ColumnID::N_STD_ID - (int)CElementRangeTable::ColumnID::MIN);
		CString sElementIdColumnName = tableInfoPtr->GetColumnName((int)CElementRangeTable::ColumnID::N_RANGE_ID - (int)CElementRangeTable::ColumnID::MIN);
		CString sElementNumColumnName = tableInfoPtr->GetColumnName((int)CElementRangeTable::ColumnID::N_RANGE_NUM - (int)CElementRangeTable::ColumnID::MIN);

		CString sSQLCommand;
		sSQLCommand.Format(_T("SELECT * FROM \'%s\' WHERE %s = %d AND %s = %d AND %s = %d;"),
			(LPCTSTR)tableInfoPtr->GetTableName(),
			(LPCTSTR)sSTDIdColumnName,
			a_nSTDId,
			(LPCTSTR)sElementIdColumnName,
			a_nElementId,
			(LPCTSTR)sElementNumColumnName,
			a_nElementNum);

		query = datastorePtr->QueryByCommand(sSQLCommand);
		ASSERT(query);
		if (!query || !query->IsValid())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Invalid quary command (%s)."), (LPCTSTR)sSQLCommand);
			ASSERT(FALSE);
			return (CDBQueryBasePtr());
		}

		// do the table related valid checking
		if (query->GetColCount() != GetTableInfo()->GetColumnCount())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("query col num value is %d, but not %d"), query->GetColCount(), GetTableInfo()->GetColumnCount());
			ASSERT(FALSE);
			return (CDBQueryBasePtr());
		}

		return query;
	}

}