#include "tfile.h"

/*
namespace {
	bool IsWindowsNT() {
		return (LONG)GetVersion()>=0;
	}
};
*/
using namespace TFileConsts;

TFile::TFile(const TFilePath &fname, uint32 flags)
	: m_hFile(NULL), m_ec(0)
{
	open_internal(fname, /*NULL,*/ flags);
}

//------------------------------------------------------------------------------

TFile::~TFile()
{
	close();
}

//------------------------------------------------------------------------------

bool TFile::open(const TFilePath &fname, uint32 flags)
{
	return open_internal(fname, flags);
}

//------------------------------------------------------------------------------

bool TFile::open_internal(const TFilePath &fname, /*const wchar_t *pwszFilename,*/ uint32 flags)
{
	close();

	// At least one of the read/write flags must be set.
	assert(flags & (kRead | kWrite));

	DWORD dwDesiredAccess = 0;

	if (flags & kRead)
		dwDesiredAccess = GENERIC_READ;
	if (flags & kWrite)
		dwDesiredAccess |= GENERIC_WRITE;

	// Win32 docs are screwed here -- FILE_SHARE_xxx is the inverse of a deny flag.

	DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
	if (flags & kDenyRead)
		dwShareMode = FILE_SHARE_WRITE;
	if (flags & kDenyWrite)
		dwShareMode &= ~FILE_SHARE_WRITE;

	// One of the creation flags must be set.
	assert(flags & kCreationMask);

	DWORD dwCreationDisposition;

	uint32 creationType = flags & kCreationMask;

	switch (creationType) {
	case kOpenExisting:
		dwCreationDisposition = OPEN_EXISTING;
		break;
	case kOpenAlways:
		dwCreationDisposition = OPEN_ALWAYS;
		break;
	case kCreateAlways:
		dwCreationDisposition = CREATE_ALWAYS;
		break;
	case kCreateNew:
		dwCreationDisposition = CREATE_NEW;
		break;
	case kTruncateExisting:
		dwCreationDisposition = TRUNCATE_EXISTING;
		break;
	default:
		assert(0);
		return false;
	}

	assert((flags & (kSequential | kRandomAccess)) != (kSequential | kRandomAccess));

	DWORD dwAttributes = FILE_ATTRIBUTE_NORMAL;

	if (flags & kSequential)
		dwAttributes |= FILE_FLAG_SEQUENTIAL_SCAN;
	if (flags & kRandomAccess)
		dwAttributes |= FILE_FLAG_RANDOM_ACCESS;
	if (flags & kWriteThrough)
		dwAttributes |= FILE_FLAG_WRITE_THROUGH;
	if (flags & kUnbuffered)
		dwAttributes |= FILE_FLAG_NO_BUFFERING;
	/*
if (pwszFilename && !IsWindowsNT())
	pszFilename = VDFastTextWToA(pwszFilename);
*/
	//if (pszFilename)
	m_hFile = CreateFileW(fname.getWideString().c_str(), dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwAttributes, NULL);
	/*
else
	m_hFile = CreateFileW(pwszFilename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwAttributes, NULL);
*/
	//VDFastTextFree();

	// INVALID_HANDLE_VALUE isn't NULL.  *sigh*

	if (m_hFile == INVALID_HANDLE_VALUE) {
		m_hFile = NULL;

		m_ec = GetLastError();

		if (m_ec == ERROR_FILE_NOT_FOUND)
			return false;

		if (m_ec == ERROR_PATH_NOT_FOUND && creationType == kOpenExisting)
			return false;

		/*
  VDStringA fname(TFileSplitPathRight(pszFilename?VDString(pszFilename):VDTextWToA(VDStringW(pwszFilename))));

	throw MyWin32Error("Cannot open file \"%s\":\n%%s", err, fname.c_str());
  */
	}

	m_FilePosition = 0;

	return true;
}

//------------------------------------------------------------------------------

bool TFile::close()
{
	if (m_hFile) {
		HANDLE h = m_hFile;
		m_hFile = NULL;
		if (!CloseHandle(h)) {
			m_ec = GetLastError();
			return false;
		}
	}
	return true;
}

//------------------------------------------------------------------------------

bool TFile::truncate()
{
	DWORD rc = SetEndOfFile(m_hFile);
	if (rc)
		m_ec = GetLastError();
	return 0 != rc;
}

//------------------------------------------------------------------------------

TINT32 TFile::read(void *buffer, TINT32 length)
{
	DWORD dwActual;

	if (!ReadFile(m_hFile, buffer, (DWORD)length, &dwActual, NULL)) {
		m_ec = GetLastError();
		return 0;
	}

	m_FilePosition += dwActual;

	return dwActual;
}

//------------------------------------------------------------------------------

TINT32 TFile::write(const void *buffer, TINT32 length)
{
	DWORD dwActual;

	if (!WriteFile(m_hFile, buffer, (DWORD)length, &dwActual, NULL) || dwActual != (DWORD)length) {
		m_ec = GetLastError();
		return 0;
	}

	m_FilePosition += dwActual;

	return dwActual;
}

//------------------------------------------------------------------------------

bool TFile::seek(TINT64 newPos, SeekMode mode)
{
	DWORD dwMode;

	switch (mode) {
	case seekStart:
		dwMode = FILE_BEGIN;
		break;
	case seekCur:
		dwMode = FILE_CURRENT;
		break;
	case seekEnd:
		dwMode = FILE_END;
		break;
	default:
		assert(0);
		return false;
	}

	union {
		TINT64 pos;
		LONG l[2];
	} u = {newPos};

	u.l[0] = SetFilePointer(m_hFile, u.l[0], &u.l[1], dwMode);

	if (u.l[0] == -1 && GetLastError() != NO_ERROR) {
		m_ec = GetLastError();
		return false;
	}

	m_FilePosition = u.pos;
	return true;
}

//------------------------------------------------------------------------------

bool TFile::skip(TINT64 delta)
{
	if (!delta)
		return true;

	char buf[1024];

	if (delta <= sizeof buf)
		return (TINT32)delta == read(buf, (TINT32)delta);
	else
		return seek(delta, seekCur);
}

//------------------------------------------------------------------------------

TINT64 TFile::size()
{
	union {
		UINT64 siz;
		DWORD l[2];
	} u;

	u.l[0] = GetFileSize(m_hFile, &u.l[1]);

	DWORD err;

	if (u.l[0] == (DWORD)-1L && (err = GetLastError()) != NO_ERROR)
	//throw MyWin32Error("Error retrieving file size: %%s", err);
	{
		m_ec = GetLastError();
		return (TINT64)(-1);
	}
	return (TINT64)u.siz;
}

//------------------------------------------------------------------------------

TINT64 TFile::tell()
{
	return m_FilePosition;
}

//------------------------------------------------------------------------------

bool TFile::isOpen()
{
	return m_hFile != 0;
}

//------------------------------------------------------------------------------

string TFile::getLastError()
{
	LPVOID lpMsgBuf;
	FormatMessage(
		FORMAT_MESSAGE_ALLOCATE_BUFFER |
			FORMAT_MESSAGE_FROM_SYSTEM |
			FORMAT_MESSAGE_IGNORE_INSERTS,
		NULL,
		m_ec,
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
		(LPTSTR)&lpMsgBuf,
		0,
		NULL);
	string s = string(reinterpret_cast<char *>(lpMsgBuf));
	LocalFree(lpMsgBuf);
	return s;
}