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

#include <windows.h>

#include <string>
#include <vector>

#include <IIEP_FileIn.H>
#include <IIEP_Hash.H>
#include <IIEP_String.H>

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

struct MEM_FILE_IDX
{
  MEM_FILE_IDX(void)
  {
    m_dwID     = 0;
    m_dwLength = 0;
    m_pucData  = 0;
  }

  DWORD m_dwID;     // hash ID of filename
  DWORD m_dwLength; // file length
  PBYTE m_pucData;  // memory pointer
};

static std::vector <MEM_FILE_IDX> s_vecMemFile;

// ------------------------------------------------------------------------------------------------
// name: SearchMemFile()
// desc:
// ------------------------------------------------------------------------------------------------

static std::vector <MEM_FILE_IDX> :: iterator SearchMemFile(PCWSTR pcwsFileName)
{
  DWORD dwID = IIEP::HashFNV_1a(pcwsFileName);

  std::vector <MEM_FILE_IDX>::iterator it;

  for (it = s_vecMemFile.begin(); it < s_vecMemFile.end(); it ++)
  {
      if (it -> m_dwID == dwID) return it;
  }

  return s_vecMemFile.end();
}

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

static std::vector <MEM_FILE_IDX> :: iterator SearchMemFile(const char *pcszFileName)
{
  WORD wzNameBuffer[0x1000];

  wzNameBuffer[0] = 0;

  IIEP::StringFromANSI(pcszFileName, wzNameBuffer, 0x1000);

  return SearchMemFile(wzNameBuffer);
}

// ------------------------------------------------------------------------------------------------
// name: CreateMemoryFile()
// desc:
// ------------------------------------------------------------------------------------------------

bool IIEP::CreateMemoryFile(PVOID pMemory, DWORD dwLength, PCWSTR pcwsFileName)
{
  if (0 == pcwsFileName || 0 == *pcwsFileName) return false;

  RemoveMemoryFile(pcwsFileName);

  DWORD dwID = IIEP::HashFNV_1a(pcwsFileName);

  MEM_FILE_IDX soIDX;

  soIDX.m_dwID     = dwID;
  soIDX.m_dwLength = dwLength;
  soIDX.m_pucData  = (PBYTE) pMemory;

  s_vecMemFile.push_back(soIDX);

  return true;
}

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

bool IIEP::CreateMemoryFile(PVOID pMemory, DWORD dwLength, const char *pcszFileName)
{
  WORD wzNameBuffer[0x1000];

  wzNameBuffer[0] = 0;

  StringFromANSI(pcszFileName, wzNameBuffer, 0x1000);

  return CreateMemoryFile(pMemory, dwLength, wzNameBuffer);
}

// ------------------------------------------------------------------------------------------------
// name: RemoveMemoryFile()
// desc:
// ------------------------------------------------------------------------------------------------

bool IIEP::RemoveMemoryFile(PCWSTR pcwsFileName)
{
  if (0 == pcwsFileName || 0 == *pcwsFileName) return false;

  std::vector <MEM_FILE_IDX>::iterator it = SearchMemFile(pcwsFileName);

  if (it == s_vecMemFile.end()) return false;

  s_vecMemFile.erase(it);

  return true;
}

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

bool IIEP::RemoveMemoryFile(const char *pcszFileName)
{
  WORD wzNameBuffer[0x1000];

  wzNameBuffer[0] = 0;

  StringFromANSI(pcszFileName, wzNameBuffer, 0x1000);

  return RemoveMemoryFile(wzNameBuffer);
}

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

void IIEP::RemoveMemoryFile(void)
{
  s_vecMemFile.clear();
}

// ------------------------------------------------------------------------------------------------
// name: CFileIn()
// desc:
// ------------------------------------------------------------------------------------------------

IIEP::CFileIn::CFileIn(void)
{
  m_pFile      = 0;
  m_pucMemData = 0;
  m_dwLength   = 0;
  m_dwReadPos  = 0;
}

// ------------------------------------------------------------------------------------------------
// name: ~CFileIn()
// desc:
// ------------------------------------------------------------------------------------------------

IIEP::CFileIn::~CFileIn(void)
{
  Close();
}

// ------------------------------------------------------------------------------------------------
// name: Open()
// desc:
// ------------------------------------------------------------------------------------------------

bool IIEP::CFileIn::Open(const char *pcszFileName)
{
  WORD wzNameBuffer[0x1000];

  wzNameBuffer[0] = 0;

  StringFromANSI(pcszFileName, wzNameBuffer, 0x1000);

  return Open(wzNameBuffer);
}

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

bool IIEP::CFileIn::Open(const WORD *pcwsFileName)
{
  Close();

  if (0 == pcwsFileName || 0 == *pcwsFileName) return false;

  std::vector <MEM_FILE_IDX>::iterator it = SearchMemFile(pcwsFileName);

  if (it == s_vecMemFile.end()) // not found in memory
  {
    m_pFile = _wfopen(pcwsFileName, L"rb");

    if (m_pFile)
    {
      return true;  // found DOS file
    }

    return false;
  }

  if (s_vecMemFile.empty()) return false;

  m_pucMemData = it -> m_pucData;
  m_dwLength   = it -> m_dwLength;

  return true;
}

// ------------------------------------------------------------------------------------------------
// name: Close()
// desc:
// ------------------------------------------------------------------------------------------------

void IIEP::CFileIn::Close(void)
{
  if (m_pFile)
  {
    fclose(m_pFile);

    m_pFile = 0;
  }

  m_pucMemData = 0;
  m_dwLength   = 0;
  m_dwReadPos  = 0;
}

// ------------------------------------------------------------------------------------------------
// name: GetFileSize()
// desc:
// ------------------------------------------------------------------------------------------------

DWORD IIEP::CFileIn::GetFileSize(void) const
{
  if (m_pFile)
  {
    DWORD dwPostion = ftell(m_pFile);

    fseek(m_pFile, 0, SEEK_END);

    DWORD dwFileSize = ftell(m_pFile);

    fseek(m_pFile, dwPostion, SEEK_SET);

    return dwFileSize;
  }

  return m_dwLength;
}

// ------------------------------------------------------------------------------------------------
// name: GetReadPosition()
// desc:
// ------------------------------------------------------------------------------------------------

DWORD IIEP::CFileIn::GetReadPosition(void) const
{
  if (m_pFile)
  {
    return ftell(m_pFile);
  }

  return m_dwReadPos;
}

// ------------------------------------------------------------------------------------------------
// name: Seek()
// desc:
// ------------------------------------------------------------------------------------------------

bool IIEP::CFileIn::Seek(long nOffset, long nOrigin)
{
  if (m_pFile)
  {
    return (0 == fseek(m_pFile, nOffset, nOrigin));
  }

  if (m_pucMemData)
  {
    switch (nOrigin)
    {
    case SEEK_SET:
      if (nOffset < 0 || nOffset >= (long) m_dwLength) return false;
      m_dwReadPos = nOffset;
      return true;

    case SEEK_CUR:
      nOffset += m_dwReadPos;
      if (nOffset < 0 || nOffset >= (long) m_dwLength) return false;
      m_dwReadPos = nOffset;
      return true;

    case SEEK_END:
      ASSERT(nOffset <= 0);   // 这个必须是负数
      nOffset = m_dwLength - 1 + nOffset;
      if (nOffset < 0 || nOffset >= (long) m_dwLength) return false;
      m_dwReadPos = nOffset;
      return true;
    }
  }

  return false;
}

// ------------------------------------------------------------------------------------------------
// name: Read()
// desc:
// ------------------------------------------------------------------------------------------------

DWORD IIEP::CFileIn::Read(PVOID pDataBuffer, DWORD dwReadSize)
{
  if (m_pFile)
  {
    return (DWORD) fread(pDataBuffer, 1, dwReadSize, m_pFile);
  }

  if (m_pucMemData)
  {
    if (m_dwReadPos + dwReadSize > m_dwLength) dwReadSize = m_dwLength - m_dwReadPos;

    memcpy(pDataBuffer, m_pucMemData + m_dwReadPos, dwReadSize);

    m_dwReadPos += dwReadSize;

    return dwReadSize;
  }

  return 0;
}

// ------------------------------------------------------------------------------------------------
// name: ReadAnsiLine()
// desc:
// ------------------------------------------------------------------------------------------------

bool IIEP::CFileIn::ReadAnsiLine(std::string &strLine)
{
  BYTE ucChar = 0;

  strLine.clear();

  while (ReadB(ucChar))
  {
    if (0x0D == ucChar)
    {
    }
    else
    if (0x0A == ucChar)
    {
      return true;
    }
    else
    {
      strLine.push_back(ucChar);
    }
  }

  if (strLine.empty()) return false;

  return true;
}

// ------------------------------------------------------------------------------------------------
// name: ReadUnicodeLine()
// desc:
// ------------------------------------------------------------------------------------------------

bool IIEP::CFileIn::ReadUnicodeLine(std::wstring &wstrLine, bool bBigEndian)
{
  WORD wChar  = 0;

  wstrLine.clear();

  while (bBigEndian ? ReadInverseW(wChar) : ReadW(wChar))
  {
    if (0x000D == wChar)
    {
    }
    else
    if (0x000A == wChar)
    {
      return true;
    }
    else
    {
      wstrLine.push_back(wChar);
    }
  }

  if (wstrLine.empty()) return false;

  return true;
}

// ------------------------------------------------------------------------------------------------
// name: ReadAnsiString()
// desc:
// ------------------------------------------------------------------------------------------------

bool IIEP::CFileIn::ReadAnsiString(char *pszBuffer, DWORD dwBufferLength)
{
  DWORD dwIndex = 0;
  BYTE  ucChar;

  while (ReadB(ucChar))
  {
    if (dwIndex >= dwBufferLength) return true;

    pszBuffer[dwIndex ++] = ucChar;

    if (0 == ucChar)
    {
      return true;
    }
  }

  return false;
}

// ------------------------------------------------------------------------------------------------
// name: ReadUnicodeString()
// desc:
// ------------------------------------------------------------------------------------------------

bool IIEP::CFileIn::ReadUnicodeString(WORD *pwzBuffer, DWORD dwBufferLength)
{
  DWORD dwIndex = 0;
  WORD  wChar;

  ReadInverseW(wChar);

  if (wChar == 0xFFFE)  // Unicode
  {
    while (ReadW(wChar))
    {
      if (dwIndex >= dwBufferLength) return true;

      pwzBuffer[dwIndex ++] = wChar;

      if (0 == wChar)
      {
        return true;
      }
    }
  }
  else
  if (wChar == 0xFEFF)  // Unicode big endian
  {
    while (ReadInverseW(wChar))
    {
      if (dwIndex >= dwBufferLength) return true;

      pwzBuffer[dwIndex ++] = wChar;

      if (0 == wChar)
      {
        return true;
      }
    }
  }

  return false;
}

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