/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
#ifndef NASTDIOFILE_H
#define NASTDIOFILE_H

#include "Platform.h"
#include "stdio.h"
#include "fcntl.h"
#include "errno.h"
#include "NABoolean.h"
#include "ComASSERT.h"


#include "NAWinNT.h"

// Forward Declaration
class CNAProcess;
class CNAStdioFile;


// The CNADataSource class calls ctime to get time information.  This
// define sets up the length returned from ctime which includes the
// null terminator
#define CTIME_LENGTH 26

// The NSK platform defines a special OSS error code ENOERR which indicates
// no error.  The WINDOWS platform does not.  For consistency, add the 
// define for the windows platform.
//
// For bulk read operations on Windows NT platforms, we call the
// Microsoft function ::GetLastError to receive the Microsoft error
// code instead of using the C runtime static errno variable.  The
// ::GetLastError function returns the Microsoft pre-defined literal
// ERROR_SUCCESS when a previous bulk read operation was successful.
// Since both ENOERR and ERROR_SUCCESS equal to zero, for simplicity,
// we can safely use ENOERR in place of ERROR_SUCCESS for both bulk
// read and other stdio operations.
#define ENOERR 0

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

class CNADataSource{

public:
    enum EOpenMode { eRead, eReadBulk, eWrite, eAppend, eReadBinary, eWriteBinary, eReadWrite };

public:

    CNADataSource();
    virtual ~CNADataSource();

    virtual NABoolean Open(const char *sourceName, EOpenMode mode)=0;
    virtual void Close()=0;

    virtual Int32 ReadString(char *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE)=0;
    virtual Int32 Read(void *buffer, Lng32 bufferSize)=0;
    virtual NABoolean ReadLine(char *buffer, Lng32 bufferSize)=0;
    virtual Int32 ReadBlock(char *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE)=0;

    virtual Int32 WriteString(const char *strLine)=0;
    virtual Int32 Write(const char *buffer, Lng32 bufferSize)=0;

    virtual ULng32 CheckIOCompletion()=0;
    virtual NABoolean IsEOF()=0;
    void SetFileName(const char *fileName) { m_sourceName = fileName; }

    // double-byte typed string related routines
    NAWchar* GetNewlineStringInWchar()     { return m_newlineStrWchar; }
    virtual Int32 Write(const NAWchar *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE)=0;
    TCHAR * GetNewlineString() { return m_newlineStr; }

    NABoolean IsBulkReadOperation() const { return m_bulkRead; }

    // m_lastError contains the file system error (or ENOERR) encountered
    // during the last I/O call to OSS. The OSS subsystem stores the
    // file system error in the errno static variable defined in the
    // errno.h include file released as part of Guardian
    // (see $system.system.errnoh for the lastest version).
    //
    // Note that we purposely use the same name as the Microsoft
    // function ::GetLastError to prevent the methods in the derived
    // classes (e.g., class CNALogfile) from inadvertently calling the
    // Microsoft function GetLastError instead of the inherited
    // GetLastError (i.e., CNAStdioFile::GetLastError) method.  If
    // those methods really want to invoke the Microsoft function
    // ::GetLastError directly, they should specify the name
    // ::GetLastError explicitly.
    Int32 GetLastError() const { return m_lastError; }
    // Since both the Microsoft pre-defined literal ERROR_SUCCESS
    // and the literal ENOERR equal to zero, for simplicity,
    // we can safely use the (...GetLastError() != ENOERR) check
    // for both bulk read and other stdio operations.  For example:
    //
    //   if (this->GetLastError() != ENOERR)  // an error has occurred
    //   {
    //     if (IsBulkReadOperation())
    //     {
    //       #ifdef NA_WINNT
    //         if (GetLastErrorAsDword() == ERROR_INVALID_HANDLE)
    //           /* handle error ERROR_INVALID_HANDLE */ ;
    //         else
    //           /* more error handling code ... */ ;
    //       #else
    //         throw -1;
    //       #endif
    //     }
    //     else
    //     {
    //       if (this->GetLastError() == EBADF)
    //         /* handle error EBADF */ ;
    //       else
    //         /* more error handling code ... */ ;
    //     }
    //   }
    //
    // Note that GetLastError calls in the code above invoke the
    // CNAStdioFile::GetLastError method.

protected:
    // flip byer order for each double byte character in the buffer. Throw
    // an exception (-1) if bufferSize is not even.
    void FlipByteOrder(char* buffer, Lng32 bufferSize);
    void FlipByteOrder(char* buffer, TInt64 bufferSize);

    // Helper methods
    void GetTimeString( char *pTime, NABoolean convertSpaceColonToDash );

protected:
    NABoolean             m_bulkRead;
    TCHAR            m_newlineStr[3];
    NAWchar          m_newlineStrWchar[3];
    const char  *m_sourceName;  // Process Name or File Name
    Int32              m_lastError;

};

//--------------------------------------------------------------------------------
class CNAProcess : public CNADataSource{

    typedef CNADataSource inherited;

public:

        CNAProcess();
        ~CNAProcess();

        NABoolean Open(const char *sourceName, EOpenMode mode);
        void Close();

        Int32 ReadString(char *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE);
        Int32 Read(void *buffer, Lng32 bufferSize);
        NABoolean ReadLine(char *buffer, Lng32 bufferSize);
        Int32 ReadBlock(char *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE);

        Int32 WriteString(const char *strLine);
        Int32 Write(const char *buffer, Lng32 bufferSize);

        ULng32 CheckIOCompletion();
        NABoolean IsEOF();

        // double-byte typed string related routines
        Int32 Write(const NAWchar *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE);

protected:
        short                   m_fileHandle;

};

// Class CNAPopenProcess is only available for NSK...

//----------------------------------------------------------------------------------
class CNAStdioFile : public CNADataSource{

    typedef CNADataSource inherited;

public: // functions

    // constructor and destructor
    CNAStdioFile();
    ~CNAStdioFile();

    NABoolean Open(const char *sourceName, EOpenMode mode);
    void Close();

    Int32 ReadString(char *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE);
    Int32 Read(void *buffer, Lng32 bufferSize);
    Int32 ReadBlock(char *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE);
    NABoolean ReadLine(char *buffer, Lng32 bufferSize);

    Int32 WriteString(const char *strLine);
    Int32 Write(const char *buffer, Lng32 bufferSize);
    Int32 Flush ();

    ULng32 CheckIOCompletion();
    NABoolean IsEOF();
    NABoolean IsOpen();

    // double-byte typed string related routines
    Int32 Write(const NAWchar *buffer, Lng32 bufferSize, NABoolean flipByteOrder = FALSE);
    FILE *GetFileHandle() { return m_fileHandle; }

    NABoolean Initialize();
protected:
    FILE            *m_fileHandle;
 
};

//---------------------------------------------------------------------------------
inline NABoolean CNADataSource::Open(const char *fileName, CNADataSource::EOpenMode mode)
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline Int32 CNADataSource::ReadBlock(char *buffer, Lng32 bufferSize, NABoolean flipByteOrder)
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline ULng32 CNADataSource::CheckIOCompletion()
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline void CNADataSource::Close()
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
}

inline NABoolean CNADataSource::IsEOF()
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline NABoolean CNADataSource::ReadLine(char *buffer, Lng32 bufferSize)
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline Int32 CNADataSource::ReadString(char *buffer, Lng32 bufferSize, NABoolean flipByteOrder)
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline Int32 CNADataSource::Read(void *buffer, Lng32 bufferSize)
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline Int32 CNADataSource::WriteString(const char *strLine)
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline Int32 CNADataSource::Write(const char *buffer, Lng32 bufferSize)
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline Int32 CNADataSource::Write(const NAWchar *buffer, Lng32 bufferSize, NABoolean flipByteOrder)
{
    // Added to take care of unresolved externals in MXCMP
    ComASSERT(FALSE);
    return 0;
}

inline NABoolean CNAStdioFile::IsOpen( void )
{
  return (m_fileHandle) ? TRUE : FALSE;
}

inline NABoolean CNAStdioFile::Initialize( void )
{
  if (!m_fileHandle)
  {
    // Note that both the NSK literal ENOERR and the
    // Microsoft literal ERROR_SUCCESS equal to zero.
    if (m_lastError == ENOERR)
    {
      if (IsBulkReadOperation())
      {
        m_lastError = (Int32)ERROR_INVALID_HANDLE;
      }
      else
        m_lastError = EBADF;
    }
    return FALSE;
  }
  m_lastError = ENOERR;
  return TRUE;
}

#endif