// Copyright 1993 Nildram Software. All rights reserved.
// May not be copied, except for backup purposes, without express written
// permission from Nildram Software
#include "stdafx.h"
#include <io.h>
#include <stdio.h>

#include "indexmgr.h"

/*int mymemcmp(void *pszString1,void *pszString2,int nCount)
{
	LPSTR pszStr1 = (LPSTR)pszString1;
	LPSTR pszStr2 = (LPSTR)pszString2;
	UCHAR ch1,ch2;
	for ( int Loop=0;Loop<nCount;Loop++ ) {
		ch1 = pszStr1[Loop];
		ch2 = pszStr2[Loop];
		if ( ch1 != ch2 ) {
			if ( ch1 > ch2 )
				return 1;
			else
				return -1;
		} 
	}
	return 0;
}
*/
IndexMgr::IndexMgr(const char *fname, int itsize, int unique) :
	FileMgr(fname, idxRecSize, caReadWrite, moClosed)
{
	m_nIndexSize = itsize;
	m_nUnique = unique;
	m_pnmNode = new NodeMgr(idxRecSize, m_nIndexSize);
	m_lIndexSite0 = m_nFileMgrHdrSize;
	m_lIndexSite1 = m_nFileMgrHdrSize + 4;
	m_lIndexSite2 = m_nFileMgrHdrSize + 8;
	m_lIndexSite3 = m_nFileMgrHdrSize + 12;
	m_nFileMgrHdrSize += 16; 
	m_nIsCreatedIdx = 0;
	FileMgr::open_file(); 
	m_nHighSearchRoute = -1;
	DiskMgr::read(m_nFileHandle, &m_lContentOfSite0, m_lIndexSite0, 4);
	DiskMgr::read(m_nFileHandle, &m_lContentOfSite1, m_lIndexSite1, 4);
	rew();
}

IndexMgr::IndexMgr(const char *fname, int itsize, int unique, int file_des, int idxno, int create) :
	FileMgr(fname, idxRecSize, caReadWrite, moAlreadyOpen, file_des)
{
	m_nIndexSize = itsize;
	m_nUnique = unique;
	m_pnmNode = new NodeMgr(idxRecSize, m_nIndexSize);
	m_lIndexSite0 = m_nFileMgrHdrSize + (idxno * 16);
	m_lIndexSite1 = m_lIndexSite0 + 4;
	m_lIndexSite2 = m_lIndexSite0 + 8;
	m_lIndexSite3 = m_lIndexSite0 + 12;
	m_nFileMgrHdrSize += (idxno + 1) * 16;
	if ( create )
		create_idx();
	m_nHighSearchRoute = -1;
	DiskMgr::read(m_nFileHandle, &m_lContentOfSite0, m_lIndexSite0, 4);
	DiskMgr::read(m_nFileHandle, &m_lContentOfSite1, m_lIndexSite1, 4);
	rew();
}

IndexMgr::~IndexMgr(void)
{
	delete m_pnmNode;
}

void IndexMgr::create_idx(void)
{
	m_nIsCreatedIdx = 1;
	m_lContentOfSite2 = m_lContentOfSite3 = 0;
	m_pnmNode->reset(); 
	FileMgr::insert();
	DiskMgr::write(m_nFileHandle, &m_lBlockRecNum, m_lIndexSite0, sizeof(m_lBlockRecNum));
	DiskMgr::write(m_nFileHandle, &m_lBlockRecNum, m_lIndexSite1, sizeof(m_lBlockRecNum)); 
	DiskMgr::write(m_nFileHandle, &m_lContentOfSite2, m_lIndexSite2, 4);
	DiskMgr::write(m_nFileHandle, &m_lContentOfSite3, m_lIndexSite3, 4);
}

void IndexMgr::read_data(void *block)
{
	m_pnmNode->read_data((char *)block);
}

void IndexMgr::write_data(void *block)
{
	m_pnmNode->write_data((char *)block);
}

long IndexMgr::FindCore(void *pszKeyWord, long recno)
{
	m_laSearchRoute[++m_nHighSearchRoute] = recno;
	read(recno);
	long lPointer = m_pnmNode->find( (char *)pszKeyWord );
	if ( lPointer != -1 && !m_pnmNode->isleaf() )
		return FindCore(pszKeyWord, lPointer);
	if ( compare(pszKeyWord) != 0 )
	   return -1;
	return lPointer;
}

long IndexMgr::find(void *pszKeyWord)
{
	m_nHighSearchRoute = -1;
	
	for (;;)
	{
		long retval;
		//read_head_info();
		retval = FindCore(pszKeyWord, m_lContentOfSite0);
		//if (retval != -1 )
		return retval;
	}
}

void IndexMgr::node_split(void)
{
	long recno;
	char *block1 = new char[idxRecSize];
	char *block2 = new char[idxRecSize];
	char *szIndex1 = new char[m_nIndexSize];
	char *szIndex2 = new char[m_nIndexSize];
	//inc_node_split();
	for (int x = m_nHighSearchRoute; x >= 0; x--)
	{
		recno = m_laSearchRoute[x];
		FileMgr::read(recno);
		m_pnmNode->split(block1, block2);
		
		m_pnmNode->read_data(block2);
		m_pnmNode->set_LeftNode(recno);
		long right_node = m_pnmNode->get_RightNode();
		m_pnmNode->get_high_item(szIndex2);
		FileMgr::insert();
		
		long new_rec = m_lBlockRecNum;
		m_lBlockRecNum = recno;
		m_pnmNode->read_data(block1);
		m_pnmNode->set_RightNode(new_rec);
		m_pnmNode->get_high_item(szIndex1);
		FileMgr::amend();
		
		if (right_node != -1)
		{
			FileMgr::read(right_node);
			m_pnmNode->set_LeftNode(new_rec);
			FileMgr::amend();
		}
		if (x == 0) 
		{
			m_pnmNode->reset(stNotLeaf);
			m_pnmNode->insert(recno, szIndex1);
			m_pnmNode->insert(new_rec, szIndex2);
			FileMgr::insert();
			m_lContentOfSite0 = m_lBlockRecNum;
			DiskMgr::write(m_nFileHandle, &m_lBlockRecNum, m_lIndexSite0, sizeof(m_lBlockRecNum));
		}
		else
		{
			read(m_laSearchRoute[x - 1]);
			m_pnmNode->find(szIndex2);
			m_pnmNode->erase();
			m_pnmNode->insert(recno, szIndex1);
			int retval = m_pnmNode->insert(new_rec, szIndex2);
			FileMgr::amend();
			if (retval != noFull)
				break;
		}
	}
	delete szIndex2;
	delete szIndex1;
	delete block2;
	delete block1;
}

int IndexMgr::insert(long recno, void *pszKeyWord)
{
	//lockfile();
	find(pszKeyWord);
	switch (m_pnmNode->insert(recno, (char *)pszKeyWord))
	{
		case noFull:
			amend();
			node_split();
			//unlock();
			return 0;

		case noDuplicate:
			//unlock();
			return noDuplicate;
	}
	amend();
	//unlock();
	return 0;
}

int IndexMgr::erase(void)
{
	if (m_lBlockRecNum == -1)
		return -1;
	//lockfile();
	//if (relocate() == -1)
	//{
	//	unlock();
	//	return -1;
	//}
	long RightNode_if_del = m_pnmNode->get_RightNode();
	char *pszKeyWord = new char[m_nIndexSize];
	if (m_pnmNode->get_cur_item(pszKeyWord) == NULL)
	{
		delete pszKeyWord;
		//unlock();
		return -1;
	}
	if (m_nHighSearchRoute == -1)
		find(pszKeyWord);
	for (int x = m_nHighSearchRoute; x >= 0; x--)
	{
		m_pnmNode->get_high_item(pszKeyWord);
		switch (m_pnmNode->erase())
		{
			case noNoSelect:
				delete pszKeyWord;
				//unlock();
				return -1;

			case noEmpty:
				//inc_node_del();
				if (x == 0)
				{
					if (!m_pnmNode->isleaf()) 
					{
						m_pnmNode->reset(stLeaf);

					}
					FileMgr::amend();
					delete pszKeyWord;
					read(RightNode_if_del);
					m_pnmNode->set_CurrItemPtr_low();
					//unlock();
					return 0;
				}

				FileMgr::erase();
				long lLeftNode, lRightNode;
				lLeftNode = m_pnmNode->get_LeftNode();
				lRightNode = m_pnmNode->get_RightNode();
				if (lLeftNode != -1)
				{
					FileMgr::read(lLeftNode);
					m_pnmNode->set_RightNode(lRightNode);
					FileMgr::amend();
				}
				else
					if (m_pnmNode->isleaf()) 
					{
						if (lRightNode != -1)
							m_lContentOfSite1 = lRightNode;
						else
							m_lContentOfSite1 = m_laSearchRoute[0]; 
						DiskMgr::write(m_nFileHandle, &m_lContentOfSite1, m_lIndexSite1, 4);
					}
				if (lRightNode != -1)
				{
					FileMgr::read(lRightNode);
					m_pnmNode->set_LeftNode(lLeftNode);
					FileMgr::amend();
				}
				FileMgr::read(m_laSearchRoute[x - 1]);
				m_pnmNode->find(pszKeyWord);
				break;

			default:
				FileMgr::amend();
				if (x == 0 && !m_pnmNode->isleaf() && m_pnmNode->get_ItemNum() == 1)
				{

					m_lContentOfSite0 = m_pnmNode->read_ptr(0);
					FileMgr::erase();
					DiskMgr::write(m_nFileHandle, &m_lContentOfSite0, m_lIndexSite0, sizeof(m_lContentOfSite0));
				}
				delete pszKeyWord;
				if (x != m_nHighSearchRoute)
				{
					read(RightNode_if_del);
					m_pnmNode->set_CurrItemPtr_low();
				}
				//unlock();
				return 0;
		}
	}
	delete pszKeyWord;
	//unlock();
	return 0;
}

int IndexMgr::compare(void *pszKeyWord)
{
	char *buffer = new char[m_nIndexSize];
	if (m_pnmNode->get_cur_item(buffer) == NULL)
	{
	   delete buffer;
	   return 0;
	}

	int retval;
	if (m_nUnique)
		retval = memcmp(pszKeyWord, buffer, m_nIndexSize);
	else
		retval = memcmp(pszKeyWord, buffer, m_nIndexSize - 4);
	delete buffer;
	return retval;
}

long IndexMgr::retrieve(void)
{
	if (m_lBlockRecNum == -1)
		return -1;
	//if (relocate() == -1)
	//	return -1;
	return m_pnmNode->retrieve();
}

long IndexMgr::next(int no_recs)
{
	long retval = -1;
	for (; no_recs > 0; no_recs--)
	{
		//relocate();
		retval = m_pnmNode->next();
		while (retval == -1)
		{
			m_nHighSearchRoute = -1;
			long lRightNode = m_pnmNode->get_RightNode();
			if (lRightNode == -1)
				return -1;
			read(lRightNode);
			m_pnmNode->set_CurrItemPtr_low();
			retval = m_pnmNode->next();
		}
	}
	return retval;
}

long IndexMgr::prev(int no_recs)
{
	long retval = -1;
	for (; no_recs > 0; no_recs--)
	{
		//relocate();
		retval = m_pnmNode->prev();
		while (retval == -1)
		{
			m_nHighSearchRoute = -1;
			long lLeftNode = m_pnmNode->get_LeftNode();
			if (lLeftNode == -1)
				return -1;
			read(lLeftNode);
			m_pnmNode->set_CurrItemPtr_high();
			retval = m_pnmNode->prev();
		}
	}
	return retval;
}

void IndexMgr::rew(void)
{
	//read_head_info();
	read(m_lContentOfSite1);
	m_pnmNode->set_CurrItemPtr_low();
	m_nHighSearchRoute = -1;
}

void IndexMgr::ffwd_core(long recno)
{
	m_laSearchRoute[++m_nHighSearchRoute] = recno;
	read(recno);
	long lTepRecno = m_pnmNode->ffwd_core();
	if (lTepRecno != -1 && !m_pnmNode->isleaf())
		ffwd_core(lTepRecno);
	return;
}

void IndexMgr::ffwd(void)
{
	m_nHighSearchRoute = -1;
	//read_head_info();
	ffwd_core(m_lContentOfSite0);
}