ZipArchive.h

#pragma once

// #define SAVE_ZIP_HEADER

#include "Archive.h"
#include "Array.h"
#include <vector>
#include "util/mutex.h"

namespace ParaEngine
{
    using namespace std;
    class IReadFile;

    const WORD ZIP_FILE_ENCRYPTED =         0x0001; // set if the file is encrypted
    const WORD ZIP_INFO_IN_DATA_DESCRITOR = 0x0008; // the fields crc-32, compressed size
    const int ZIP_CONST_ENDHDR = 22;
    const int ZIP_CONST_LOCALHEADERSIG = 'P' | ('K' << 8) | (3 << 16) | (4 << 24);
    const int ZIP_CONST_CENSIG = 'P' | ('K' << 8) | (1 << 16) | (2 << 24);
    const DWORD ZIP_CONST_ENDSIG = 'P' | ('K' << 8) | (5 << 16) | (6 << 24);

    // and uncompressed size are set to zero in the local
    // header

    // Set byte packing for ZIP file header definition
#   pragma pack( push, packing )
#   pragma pack( 1 )

    struct ZIP_EndOfCentralDirectory
    {
        uint16_t thisDiskNumber;
        uint16_t startCentralDirDisk;
        uint16_t entriesForThisDisk;
        uint16_t entriesForWholeCentralDir;
        uint32_t centralDirSize;
        uint32_t offsetOfCentralDir;
        uint16_t commentSize;
    };

    struct ZIP_EndOfCentralDirectoryBlock
    {
        DWORD sig;
        uint16_t thisDiskNumber;
        uint16_t startCentralDirDisk;
        uint16_t entriesForThisDisk;
        uint16_t entriesForWholeCentralDir;
        uint32_t centralDirSize;
        uint32_t offsetOfCentralDir;
        uint16_t commentSize;
    };

    struct ZIP_CentralDirectory
    {
        DWORD Sig;
        WORD MadeByVersion;
        WORD ExtractVersion;
        WORD Flags;
        WORD CompressionMethod;
        WORD LastModFileTime;
        WORD LastModFileDate;
        DWORD FileCRC;
        DWORD PackSize;
        DWORD UnPackSize;
        WORD NameSize;
        WORD ExtraSize;
        WORD CommentSize;
        WORD DiskNumberStart;
        WORD InternalAttributes;
        DWORD ExternalAttributes;
        DWORD LocalHeaderOffset;
    };

    struct SZIPFileDataDescriptor
    {
        DWORD CRC32;
        DWORD CompressedSize;
        DWORD UncompressedSize;
    };

    struct SZIPFileHeader
    {
        DWORD Sig;
        WORD VersionToExtract;
        WORD GeneralBitFlag;
        WORD CompressionMethod;
        WORD LastModFileTime;
        WORD LastModFileDate;
        SZIPFileDataDescriptor DataDescriptor;
        WORD FilenameLength;
        WORD ExtraFieldLength;
    };

    // Default alignment
#   pragma pack( pop, packing )


    struct SZipFileEntry
    {
        //string zipFileName;
        WORD fileNameLen;
        const char* zipFileName;
        uint32 hashValue;
        DWORD fileDataPosition; // position of compressed data in file

        WORD CompressionMethod;
        DWORD CompressedSize;
        DWORD UncompressedSize;
#ifdef SAVE_ZIP_HEADER
        SZIPFileHeader header;
#endif 

    public:
        SZipFileEntry()
            : fileDataPosition(0), CompressedSize(0),UncompressedSize(0),CompressionMethod(0) , hashValue(0), zipFileName(nullptr), fileNameLen(0)
        {
#ifdef SAVE_ZIP_HEADER
            memset(&header, 0, sizeof(SZIPFileHeader)); 
#endif 
        };
        ~SZipFileEntry(){};

        void SetFileName(const char* str, WORD len)
        {
            zipFileName = str;
            fileNameLen = len;
        }

        void RefreshHash(bool ignoreCase)
        {
            if (zipFileName)
                hashValue = Hash(zipFileName, ignoreCase);
        }

        static uint32 Hash(const char* str, bool ignoreCase)
        {
            const size_t seed = 2166136261U;
            const size_t prime = 16777619U;
            const char diff = 'a' - 'A';

            uint32 ret = seed;

            const char* p = str;

            if (ignoreCase)
            {
                while (*p != 0)
                {
                    auto cur = *p;

                    if (cur >= 'A' && cur <= 'Z')
                        cur += diff;
                    ret ^= cur;
                    ret *= prime;

                    p++;
                }
            }
            else
            {
                while (*p != 0)
                {
                    auto cur = *p;

                    ret ^= cur;
                    ret *= prime;

                    p++;
                }
            }

            return ret;
        }
    };

    struct SZipFileEntryPtr
    {
        SZipFileEntry* m_pEntry;
    public:
        SZipFileEntryPtr():m_pEntry(NULL){};
        SZipFileEntryPtr(const SZipFileEntryPtr& entry):m_pEntry(entry.m_pEntry){};
        SZipFileEntryPtr(SZipFileEntry* pEntry):m_pEntry(pEntry){};
    };

    // check src data is zip file data
    bool IsZipData(const char* src, size_t size);
    // get first file info in zip file data
    const SZIPFileHeader* GetFirstFileInfo(const char* src, std::string* filename = nullptr);
    bool GetFirstFileData(const char* src, std::string& out);

    class CZipArchive : public CArchive
    { 
    public:
        CZipArchive(void);
        CZipArchive(bool bIgnoreCase);
        virtual ~CZipArchive(void);
        inline static DWORD TypeID() { return 2; };
        virtual DWORD GetType(){ return TypeID(); };

        ATTRIBUTE_DEFINE_CLASS(CZipArchive);
        ATTRIBUTE_METHOD1(CZipArchive, SetBaseDirectory_s, const char*) { cls->SetBaseDirectory(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CZipArchive, GetRootDirectory_s, const char**) { *p1 = cls->GetRootDirectory().c_str(); return S_OK; }
        ATTRIBUTE_METHOD1(CZipArchive, SetRootDirectory_s, const char*) { cls->SetRootDirectory(p1); return S_OK; }


        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);
        
    public:
        virtual bool Open(const string& sArchiveName, int nPriority);

        virtual void Close();

        virtual bool DoesFileExist(const string& filename);

        virtual bool OpenFile(const char* filename, FileHandle& handle);

        virtual bool OpenFile(const ArchiveFileFindItem* item, FileHandle& handle);

        /* open a zip file in memory 
        * @param buffer: 
        * @param nLen: size in byte of the buffer
        * @param bDeleteBuffer: true if the zip file will take the ownership of the buffer and will delete it on exit.
        */
        bool OpenMemFile(const char* buffer, DWORD nLen, bool bDeleteBuffer=true);

        virtual DWORD GetFileSize(FileHandle& handle);

        virtual bool ReadFile(FileHandle& handle,LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead);

        virtual bool ReadFileRaw(FileHandle& handle,LPVOID* lppBuffer,LPDWORD pnCompressedSize, LPDWORD pnUncompressedSize);

        static bool Decompress(LPVOID lpCompressedBuffer, DWORD nCompressedSize, LPVOID lpUnCompressedBuffer, DWORD nUncompressedSize);

        virtual bool CloseFile(FileHandle& hFile);

        virtual void SetRootDirectory(const string& filename);

        const std::string& GetRootDirectory();

        virtual void SetBaseDirectory(const char * filename);

        virtual void FindFiles(CSearchResult& result, const string& sRootPath, const string& sFilePattern, int nSubLevel);

        bool GeneratePkgFile(const char* filename);
        bool GeneratePkgFile2(const char* filename);

        int GetFileCount();

        virtual bool IsIgnoreCase() const { return m_bIgnoreCase;  }
    private:
        IReadFile* m_pFile;
        vector<SZipFileEntryPtr> m_FileList;
        bool m_bDirty;
        SZipFileEntry* m_pEntries;
        // save name block
        vector<char> m_nameBlock;


        bool m_bIgnoreCase;
        bool m_bRelativePath;
        string m_sRootPath;
        char* m_zipComment;
        ParaEngine::mutex m_mutex;
    private:
        int findFile(const ArchiveFileFindItem* item);


        IReadFile* openFile(int index);
        /* open a zip file. this function is only called inside OpenFile() virtual method */
        bool OpenZipFile(const string& filename);
        /* open a pkg file. this function is only called inside OpenFile() virtual method */
        bool OpenPkgFile(const string& filename);

        void ReBuild();
        int LocateBlockWithSignature(DWORD signature, long endLocation, int minimumBlockSize, int maximumVariableData);

        bool ReadEntries();

        bool _ReadEntries_pkg();
        bool ReadEntries_pkg();
        bool ReadEntries_pkg2();
    };
}