FileUtils.h

#pragma once
#include "FileData.h"
#include "FileHandle.h"
#include <map>

namespace ParaEngine
{
    class CSearchResult;

    struct CParaFileInfo
    {
        enum FileMode{
            ModeNoneExist,
            ModeFile,
            ModeFileInZip,
            ModeDirectory,
            ModeLink,
            ModeSocket,
            ModeNamedPipe,
            ModeCharDevice,
            ModeBlockDevice,
            ModeOther,
        };
    public:
        CParaFileInfo();
        
        std::string m_sFullpath;
        FileMode m_mode;
        DWORD m_dwFileAttributes;
        time_t m_ftCreationTime;
        time_t m_ftLastAccessTime;
        time_t m_ftLastWriteTime;
        DWORD m_dwFileSize;
    };

    class CFileUtils
    {
    public:

        /* remove the starting and trailing spaces ' ' from the string */
        static void TrimString(std::string & str);

        static bool FileExistRaw(const char* filename);

        static bool AddDiskSearchPath(const std::string& sFile, bool nFront = false);

        static bool FileExist(const char* filename);

        static bool FileExist2(const char* filename, std::string * pDiskFile = NULL);

        static void MakeFileNameFromRelativePath(char * output, const char* filename, const char* relativePath);

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

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


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

        static bool MakeDirectoryFromFilePath(const char * filename);

        static bool SaveBufferToFile(const std::string& filename, bool bReplace, char* buffer, DWORD nBufSize);

        static bool DeleteFile(const char* filename);

        static int DeleteDirectory(const char* dirname);

        static int DeleteFiles(const std::string& sFilePattern, bool bSecureFolderOnly = true, int nSubFolderCount=10);

        static std::string GetWritableFullPathForFilename(const std::string& filename);
        static std::string GetFileName(const std::string& sFilePath);

        static FileData GetDataFromFile(const char* filename);

        static std::string GetStringFromFile(const std::string& filename);

        static bool GetFileInfo(const char* filename, CParaFileInfo& fileInfo);

        static FileData GetResDataFromFile(const std::string& filename);

        static bool DoesResFileExist(const std::string& filename);

        static void AddEmbeddedResource(const char* name, const char* buffer, size_t nSize);

        static std::string GetFullPathForFilename(const std::string &filename);

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

        static int GetFileSize(const char* sFilePath);

        static FileHandle OpenFile(const char* sFilePath, bool bRead = false, bool bWrite=true);
        
        static bool SetFilePointer(FileHandle& fileHandle, int lDistanceToMove, int dwMoveMethod);

        static int GetFilePosition(FileHandle& fileHandle);

        static bool SetEndOfFile(FileHandle& fileHandle);
        
        static int WriteBytes(FileHandle& fileHandle, const void* src, int bytes);

        static int ReadBytes(FileHandle& fileHandle, void* dest, int bytes);

        static void CloseFile(FileHandle& fileHandle);

        static std::string GetInitialDirectory();

        static const std::string& GetWritablePath();

        static void SetWritablePath(const std::string& writable_path);

        static void FindDiskFiles(CSearchResult& result, const std::string& sRootPath, const std::string& sFilePattern, int nSubLevel);
    public:
        // this is usually /mnt/sdcard/XXX/ in android. 
        static std::string s_writepath;

    private:
        struct EmbeddedResource 
        {
        public:
            EmbeddedResource():resource_data(0), data_len(0) {}
            EmbeddedResource(const char* start, size_t len) : resource_data(start), data_len(len) {}

            const char * const &data() const { return resource_data; }
            const size_t &size() const { return data_len; }

            const char *begin() const { return resource_data; }
            const char *end() const { return resource_data + data_len; }

            std::string toString() { return std::string(data(), size()); }

        private:
            const char* resource_data;
            size_t data_len;
        };

        // all embedded resources
        static std::map<std::string, EmbeddedResource> s_all_resources;
    };

    
}