// 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 <sys\stat.h>
#include <string.h>
#include <io.h>
#include <fcntl.h>
#include <share.h>
#include <errno.h>
#include <stdlib.h>

#include "filemgr.h"

FileMgr::FileMgr(const char *fname, int rsize, int ctype, int mode, int file_des) :
	DiskMgr(ctype)
{
	m_szFileName = new char[strlen(fname) + 1];
	strcpy(m_szFileName, fname);
	m_nRecSize = rsize;
	m_nBlockSize = m_nRecSize + 2;
	m_nFileHandle = -1;
    m_nIsAlreadyOpen = 1;
	if ( mode == moOpen )
	{
		open_file();
	}
	if ( mode == moAlreadyOpen )
	{
		m_nFileHandle = file_des;
        m_nIsAlreadyOpen = 0;
		int nTmpBlockSize = -1;
        DiskMgr::read(m_nFileHandle, &nTmpBlockSize, 0, sizeof(nTmpBlockSize));
		if (nTmpBlockSize != m_nBlockSize)
		{
			AfxMessageBox("Error: Program and Data Files out of sync!");
			exit(0);
		}
	}
	m_lBlockRecNum = -1;
	m_nFileMgrHdrSize = 6;
}

FileMgr::~FileMgr(void)
{
    close_file();
	delete m_szFileName;
}

int FileMgr::create(void)
{
    long temp = -1;
	m_nFileHandle = sopen(m_szFileName, O_RDWR | O_BINARY | O_CREAT | O_TRUNC, SH_DENYRW, S_IREAD | S_IWRITE);
	if (m_nFileHandle == -1)
		return -1;
    
	DiskMgr::write(m_nFileHandle, &m_nBlockSize, 0, sizeof(m_nBlockSize));

    DiskMgr::write(m_nFileHandle, &temp, sizeof(m_nBlockSize), sizeof(temp));
	create_file();
    DiskMgr::close(m_nFileHandle);
	m_nFileHandle = -1;
	return 0;
}

int FileMgr::open_file(void)
{
	while (m_nFileHandle == -1)
	{
		m_nFileHandle = DiskMgr::open(m_szFileName, O_RDWR | O_BINARY);
		if (m_nFileHandle == -1)
		{
			switch (errno)
			{
				case ENOENT:
					create();
					break;

				case EACCES:
					break;

				default:
					return -1;
			}
		}
	}
	short nTmpBlockSize = -1;
	DiskMgr::read(m_nFileHandle, &nTmpBlockSize, 0, sizeof(nTmpBlockSize));
	if (nTmpBlockSize != m_nBlockSize)
	{
		close_file();
		return -1;
	}
	return 0;
}

void FileMgr::close_file(void)
{
	if (m_nFileHandle != -1)
	{
		m_lBlockRecNum = -1;
		//DiskMgr::unlock(m_nFileHandle);
		if (m_nIsAlreadyOpen)
            DiskMgr::close(m_nFileHandle);
		m_nFileHandle = -1;
	}
}

void FileMgr::insert(void)
{
	m_pszBlockBuffer = new char[m_nBlockSize];
	write_data(m_pszBlockBuffer + 2);
	*m_pszBlockBuffer = 0;
	*(m_pszBlockBuffer + 1) = 0;
	long lBlockRecNumWithDirection;
	//DiskMgr::lock_head(m_nFileHandle);
	DiskMgr::read(m_nFileHandle, &m_lBlockRecNum, 2, sizeof(m_lBlockRecNum));
	if (m_lBlockRecNum < 0)
	{
		m_lBlockRecNum = -1 - m_lBlockRecNum;
		lBlockRecNumWithDirection = -m_lBlockRecNum - 2;

		DiskMgr::write(m_nFileHandle, m_pszBlockBuffer, HEADSIZ + (m_lBlockRecNum * m_nBlockSize), m_nBlockSize);
	}
	else
	{
		DiskMgr::read(m_nFileHandle, &lBlockRecNumWithDirection, HEADSIZ + (m_lBlockRecNum * m_nBlockSize) + 2, sizeof(lBlockRecNumWithDirection));

		DiskMgr::write(m_nFileHandle, m_pszBlockBuffer, HEADSIZ + (m_lBlockRecNum * m_nBlockSize), m_nBlockSize);
	}
	DiskMgr::write(m_nFileHandle, &lBlockRecNumWithDirection, 2, sizeof(lBlockRecNumWithDirection));
	//DiskMgr::unlock_head(m_nFileHandle);
	delete m_pszBlockBuffer;
}


int FileMgr::amend(void)
{
	if (m_lBlockRecNum == -1)
		return -1;
	m_pszBlockBuffer = new char[m_nBlockSize];
	write_data(m_pszBlockBuffer + 2);
	*m_pszBlockBuffer = 0;
	*(m_pszBlockBuffer + 1) = 0;

	DiskMgr::write(m_nFileHandle, m_pszBlockBuffer, HEADSIZ + (m_lBlockRecNum * m_nBlockSize), m_nBlockSize);
	delete m_pszBlockBuffer;
	return 0;
}

int FileMgr::read(long recno)
{
	if (m_nFileHandle == -1)
		return -1;
	m_lBlockRecNum = recno;
	if (recno == -1)
		return -1;
	m_pszBlockBuffer = new char[m_nBlockSize];

	DiskMgr::read(m_nFileHandle, m_pszBlockBuffer, HEADSIZ + (recno * m_nBlockSize), m_nBlockSize);
	
	read_data(m_pszBlockBuffer + 2);
	delete m_pszBlockBuffer;
	return 0;
}

//int FileMgr::lock(long recno)
//{
//	if (m_nFileHandle == -1)
//		return -1;
//	if (recno == -1)
//		return -1;

	//DiskMgr::lock(m_nFileHandle, HEADSIZ + (recno * m_nBlockSize), m_nBlockSize);

//	return 0;
//}

//int FileMgr::unlock(void)
//{
//	if (m_nFileHandle == -1)
//		return -1;
	//DiskMgr::unlock(m_nFileHandle);
//	return 0;
//}

int FileMgr::next(void)
{
	if (m_nFileHandle == -1)
		return -1;
	m_pszBlockBuffer = new char[m_nBlockSize];
	//unlock();
	do	{
		m_lBlockRecNum++;
		//lock(m_lBlockRecNum);
		if (DiskMgr::read(m_nFileHandle, m_pszBlockBuffer, HEADSIZ + (m_lBlockRecNum * m_nBlockSize), m_nBlockSize) != m_nBlockSize)
		{
			delete m_pszBlockBuffer;
			//unlock();
			return -1;
		}
	} while (*(int *)m_pszBlockBuffer == rsDeleted);
	read_data(m_pszBlockBuffer + 2);
	delete m_pszBlockBuffer;
	return 0;
}

int FileMgr::erase(void)
{
	if (m_nFileHandle == -1)
		return -1;
	if (m_lBlockRecNum == -1)
		return -1;

	long nRecLabel;
	//DiskMgr::lock_head(m_nFileHandle);
	DiskMgr::read(m_nFileHandle, &nRecLabel, 2, sizeof(nRecLabel));
	DiskMgr::write(m_nFileHandle, &m_lBlockRecNum, 2, sizeof(m_lBlockRecNum));

	int nRecStyle = rsDeleted;
	write_head(nRecStyle, nRecLabel, m_lBlockRecNum);

	//DiskMgr::unlock_head(m_nFileHandle);
	m_lBlockRecNum = -1;
	return 0;
}

void FileMgr::write_head(int nRecStyle, long nRecLabel, long recno)
{
	char buffer[6];
	*(int *)buffer = nRecStyle;
	*(long *)(buffer + 2) = nRecLabel;
	DiskMgr::write(m_nFileHandle, buffer, HEADSIZ + (recno * m_nBlockSize), 6);
}