ParaFile.h

#pragma once
#include <list>
#include <vector>
#include <string>

namespace ParaEngine
{
    struct CParaFileInfo;
    class CArchive;
    
    using namespace std;
    
    enum FileLocation
    {
        FILE_NOT_FOUND = 0,
        FILE_ON_DISK = 1,
        FILE_ON_ZIP_ARCHIVE = 2,
        FILE_ON_SEARCH_PATH = 4,
        FILE_ON_EXECUTABLE = 8, // embedded resource file
    };

    class CParaFile
    {
        // disable copying
        CParaFile(const CParaFile &f);

    private:
        static string m_strExtractRootPath;
        static bool m_bExtractFileToDisk;
        static int m_nDiskFilePriority;
    public:
        PE_CORE_DECL CParaFile();

        PE_CORE_DECL CParaFile(char* buf, int nBufferSize, bool bCopyBuffer = false);

        PE_CORE_DECL CParaFile(const char* filename);
        PE_CORE_DECL CParaFile(const char* filename, const char* relativePath);
        PE_CORE_DECL ~CParaFile();
        // static method
    public:
        PE_CORE_DECL static bool CreateDirectory(const char* filename);

        PE_CORE_DECL static bool MakeDirectoryFromFilePath(const char * filename);

#ifdef WIN32
        PE_CORE_DECL static void ToCanonicalFilePath(string & output, const string& input, bool bBackSlash = true);
#else
        PE_CORE_DECL static void ToCanonicalFilePath(string & output, const string& input, bool bBackSlash = false);
#endif

#ifdef WIN32
        PE_CORE_DECL static void ToCanonicalFilePath(char* output, const char* input, bool bBackSlash = true);
#else
        PE_CORE_DECL static void ToCanonicalFilePath(char* output, const char* input, bool bBackSlash = false);
#endif

        PE_CORE_DECL static bool DoesFileExist(const char* filename, bool bSearchZipFiles = false, bool bUseSearchPath = false);

        static int32 DoesFileExist2(const char* filename, uint32 dwWhereToSearch = FILE_ON_DISK, std::string* pDiskFilePath = NULL);

        static bool IsAbsolutePath(const std::string& path);

        PE_CORE_DECL static int DeleteTempFile(const string& sFilePattern);
        PE_CORE_DECL static int DeleteFile(const string& sFilePattern, bool bSecureFolderOnly = true);

        PE_CORE_DECL static bool MoveFile(const char* src, const char* dest);

        PE_CORE_DECL static bool BackupFile(const char* filename);

        PE_CORE_DECL static unsigned long CRC32(const char* filename);

        PE_CORE_DECL static bool CopyFile(const char* src, const char* dest, bool bOverride);

        PE_CORE_DECL static string GetParentDirectoryFromPath(const string& sfilename, int nParentCounts = 0);

        PE_CORE_DECL static string AutoFindParaEngineRootPath(const string& sFile);
        PE_CORE_DECL static string ChangeFileExtension(const string& sFile, const string & sExt);

        PE_CORE_DECL static string GetFileExtension(const string& sFile);

        PE_CORE_DECL static string GetRelativePath(const string& sAbsolutePath, const string& sRootPath);

        PE_CORE_DECL static string GetAbsolutePath(const string& sRelativePath, const string& sRootPath);

        PE_CORE_DECL static string GetFileName(const string& sFilePath);

        PE_CORE_DECL static bool IsFileName(const string& sFilePath);

        PE_CORE_DECL static int GetFileSize(const char* sFilePath);

        PE_CORE_DECL static const std::string& GetWritablePath();

        PE_CORE_DECL static void SetWritablePath(const std::string& writable_path);
        PE_CORE_DECL static bool IsWritablePath(const std::string& filepath, bool bLogWarning = true);

        enum PARAENGINE_DIRECTORY{
            APP_ROOT_DIR = 0,
            APP_SCRIPT_DIR = 1,
            APP_ARCHIVE_DIR = 2, // xmodels
            APP_MODEL_DIR = 3,
            APP_SHADER_DIR = 4,
            APP_DATABASE_DIR = 5,
            APP_TEMP_DIR = 6,
            APP_USER_DIR = 7,
            APP_BACKUP_DIR = 8,
            APP_SCREENSHOT_DIR = 9,
            APP_PLUGIN_DIR = 10,
            APP_CONFIG_DIR = 11,
            APP_CHARACTER_DIR = 12,
            APP_SH_DESKTOP_DIR = 13,
            APP_SH_DESKTOP_FOLDER_DIR = 14,
            APP_SH_MYDOC_DIR = 15,
            APP_SH_FAV_DIR = 16,
            APP_SH_MUSIC_DIR = 17,
            APP_SH_PICTURE_DIR = 18,
            APP_SH_VIDEO_DIR = 19,
            APP_DEV_DIR = 20,
            APP_EXECUTABLE_DIR = 21,
            APP_LAST_DIR,
        };

        PE_CORE_DECL static const string& GetCurDirectory(DWORD dwDirectoryType);

        PE_CORE_DECL static void SetDevDirectory(const string& sFilePath);
        PE_CORE_DECL static const string& GetDevDirectory();
    public:
        static void SetDiskFilePriority(int nPriority);

        static int GetDiskFilePriority();

        PE_CORE_DECL bool OpenFile(const char* filename, bool bReadyOnly = true, const char* relativePath = NULL, bool bUseCompressed = false, uint32 dwWhereToOpen = FILE_ON_DISK | FILE_ON_ZIP_ARCHIVE | FILE_ON_SEARCH_PATH);

        PE_CORE_DECL bool OpenFile(CArchive* pArchive, const char* filename, bool bUseCompressed = false);

        PE_CORE_DECL static bool GetFileInfo(const char* filename, CParaFileInfo& fileInfo, uint32 dwWhereToOpen = FILE_ON_DISK | FILE_ON_ZIP_ARCHIVE | FILE_ON_SEARCH_PATH);

        PE_CORE_DECL int OpenAssetFile(const char* filename, bool bDownloadIfNotUpToDate = true, const char* relativePath = NULL);

        PE_CORE_DECL static bool DoesAssetFileExist(const char* filename);
        PE_CORE_DECL static bool DoesAssetFileExist2(const char* filename, bool bSearchZipFile = false);

        PE_CORE_DECL bool Decompress();

        PE_CORE_DECL bool IsCompressed();

        PE_CORE_DECL void SetIsCompressed(bool bCompressed);

        PE_CORE_DECL bool CreateNewFile(const char* filename, bool bAutoMakeFilePath = true);
        PE_CORE_DECL void GiveupBufferOwnership();
        PE_CORE_DECL void TakeBufferOwnership();

        PE_CORE_DECL bool ExtractFileToDisk(const string& filenameDest, bool bReplace);
        PE_CORE_DECL static void SetExtractFileProperty(bool bExtractFile);
        PE_CORE_DECL static bool GetExtractFileProperty();


        PE_CORE_DECL static bool UnzipMemToFile(const char* buffer, int nSize, const char* destFilename, bool bAutoMakeDirectory);

        //
        // file writing
        //

        PE_CORE_DECL int write(const void* src, int bytes);
        PE_CORE_DECL int WriteString(const string& sStr);
        PE_CORE_DECL int WriteString(const char* sStr, int nLen = 0);
        PE_CORE_DECL int WriteFormated(const char *, ...);

        inline int WriteDWORD(DWORD data){ return write(&data, sizeof(data)); }
        inline int WriteWORD(WORD data) { return write(&data, sizeof(data)); } 


        void SetFilePointer(int lDistanceToMove, int dwMoveMethod);

        bool SetEndOfFile();

        //
        // file reading: byte based
        //

        PE_CORE_DECL size_t read(void* dest, size_t bytes);

        inline DWORD ReadDWORD(){ DWORD data; read(&data, 4); return data; }
        inline WORD ReadWORD(){ WORD data; read(&data, 2); return data; }

        inline BYTE ReadByte(){ BYTE data; read(&data, 1); return data; }
        inline int WriteByte(BYTE data){ return write(&data, 1); }

        DWORD ReadDWORD_LE();
        WORD ReadWORD_LE();

        uint32_t ReadEncodedUInt();
        int WriteEncodedUInt(uint32_t value);

        PE_CORE_DECL int GetNextLine(char* buf, int sizeBuf);
        PE_CORE_DECL int SkipComment();
        PE_CORE_DECL int SkipEqualMark();

        PE_CORE_DECL int SkipString(const char* sName);

        PE_CORE_DECL int SkipCurrentLine();

        PE_CORE_DECL bool GetNextAttribute(const char * sName, string& output);
        PE_CORE_DECL bool GetNextAttribute(const char * sName, float& output);
        PE_CORE_DECL bool GetNextAttribute(const char * sName, double& output);
        PE_CORE_DECL bool GetNextAttribute(const char * sName, int& output);
        PE_CORE_DECL bool GetNextAttribute(const char * sName, bool& output);

        PE_CORE_DECL bool GetNextAttribute(const char * sName);

        template <class TYPE_ARG1>
        bool GetNextFormatted(const char * sFormat, TYPE_ARG1 a1)
        {
            bool bSucceed = false;
            SkipComment();
            size_t nOldPos = m_curPos;

            if (isEof())
                return false;
            
            const char* pSrc = getPointer();
#ifdef WIN32
            if (_snscanf(pSrc, m_size - m_curPos, sFormat, a1) >= 1)
#else
            if (sscanf(pSrc, sFormat, a1) >= 1)
#endif
            {
                bSucceed = true;
                SkipCurrentLine();
            }
            else
                m_curPos = nOldPos;

            return bSucceed;
        }
        template <class TYPE_ARG1, class TYPE_ARG2>
        bool GetNextFormatted(const char * sFormat, TYPE_ARG1 a1, TYPE_ARG2 a2)
        {
            bool bSucceed = false;
            SkipComment();
            size_t nOldPos = m_curPos;

            if (isEof())
                return false;

            const char* pSrc = getPointer();
#ifdef WIN32
            if (_snscanf(pSrc, m_size - m_curPos, sFormat, a1, a2) >= 2)
#else
            if (sscanf(pSrc, sFormat, a1, a2) >= 2)
#endif
            {
                bSucceed = true;
                SkipCurrentLine();
            }
            else
                m_curPos = nOldPos;

            return bSucceed;
        }

        template <class TYPE_ARG1, class TYPE_ARG2, class TYPE_ARG3>
        bool GetNextFormatted(const char * sFormat, TYPE_ARG1 a1, TYPE_ARG2 a2, TYPE_ARG3 a3)
        {
            bool bSucceed = false;
            SkipComment();
            size_t nOldPos = m_curPos;

            if (isEof())
                return false;

            const char* pSrc = getPointer();
#ifdef WIN32
            if (_snscanf(pSrc, m_size - m_curPos, sFormat, a1, a2, a3) >= 3)
#else
            if (sscanf(pSrc, sFormat, a1, a2, a3) >= 3)
#endif
            {
                bSucceed = true;
                SkipCurrentLine();
            }
            else
                m_curPos = nOldPos;

            return bSucceed;
        }

        //
        // common file interface functions
        //

        PE_CORE_DECL const string& GetFileName();

        PE_CORE_DECL size_t getSize();
        PE_CORE_DECL size_t getPos();
        PE_CORE_DECL char* getBuffer();
        PE_CORE_DECL inline char* getPointer(){ return m_buffer + m_curPos; }

        PE_CORE_DECL bool isEof();
        PE_CORE_DECL void seek(int offset);
        PE_CORE_DECL void seekRelative(int offset);
        PE_CORE_DECL void close();

        //
        // bit wise reading
        //

        PE_CORE_DECL void synchBits();

        PE_CORE_DECL unsigned int readUBits(int numBits);
        PE_CORE_DECL int readSBits(int numBits);

    
        void* GetHandlePtr();
    private:
        FileHandle m_handle;
        bool m_eof : 1;
        bool m_bIsOwner : 1;
        bool m_bDiskFileOpened : 1;
        bool m_bIsCompressed : 1;
        bool m_bMemoryFile : 1;
        // Force alignment to next boundary.
        DWORD: 0;
        char *m_buffer;
        size_t m_curPos;
        size_t m_size;
        size_t m_uncompressed_size;

        string m_filename;
        //--Bit buffer..This is only used for bit wise reading
        int m_bitBuf;
        int m_bitPos; // a value in range [0,8]
    };
}