#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));</char>

  LocalFree(lpMsgBuf);

  return s;

}