/* 7z.h -- 7z interface
2010-03-11 : Igor Pavlov : Public domain */

#ifndef __7Z_H
#define __7Z_H

#include "7zBuf.h"

EXTERN_C_BEGIN

#define k7zStartHeaderSize 0x20
#define k7zSignatureSize 6
extern Byte k7zSignature[k7zSignatureSize];
#define k7zMajorVersion 0

enum EIdEnum {
        k7zIdEnd,
        k7zIdHeader,
        k7zIdArchiveProperties,
        k7zIdAdditionalStreamsInfo,
        k7zIdMainStreamsInfo,
        k7zIdFilesInfo,
        k7zIdPackInfo,
        k7zIdUnpackInfo,
        k7zIdSubStreamsInfo,
        k7zIdSize,
        k7zIdCRC,
        k7zIdFolder,
        k7zIdCodersUnpackSize,
        k7zIdNumUnpackStream,
        k7zIdEmptyStream,
        k7zIdEmptyFile,
        k7zIdAnti,
        k7zIdName,
        k7zIdCTime,
        k7zIdATime,
        k7zIdMTime,
        k7zIdWinAttributes,
        k7zIdComment,
        k7zIdEncodedHeader,
        k7zIdStartPos,
        k7zIdDummy
};

typedef struct {
        UInt32 NumInStreams;
        UInt32 NumOutStreams;
        UInt64 MethodID;
        CBuf Props;
} CSzCoderInfo;

void SzCoderInfo_Init(CSzCoderInfo *p);
void SzCoderInfo_Free(CSzCoderInfo *p, ISzAlloc *alloc);

typedef struct {
        UInt32 InIndex;
        UInt32 OutIndex;
} CSzBindPair;

typedef struct {
        CSzCoderInfo *Coders;
        CSzBindPair *BindPairs;
        UInt32 *PackStreams;
        UInt64 *UnpackSizes;
        UInt32 NumCoders;
        UInt32 NumBindPairs;
        UInt32 NumPackStreams;
        int UnpackCRCDefined;
        UInt32 UnpackCRC;

        UInt32 NumUnpackStreams;
} CSzFolder;

void SzFolder_Init(CSzFolder *p);
UInt64 SzFolder_GetUnpackSize(CSzFolder *p);
int SzFolder_FindBindPairForInStream(CSzFolder *p, UInt32 inStreamIndex);
UInt32 SzFolder_GetNumOutStreams(CSzFolder *p);
UInt64 SzFolder_GetUnpackSize(CSzFolder *p);

SRes SzFolder_Decode(const CSzFolder *folder, const UInt64 *packSizes, ILookInStream *stream,
                     UInt64 startPos, Byte *outBuffer, size_t outSize, ISzAlloc *allocMain);

typedef struct {
        UInt32 Low;
        UInt32 High;
} CNtfsFileTime;

typedef struct {
        CNtfsFileTime MTime;
        UInt64 Size;
        UInt32 Crc;
        UInt32 Attrib;
        Byte HasStream;
        Byte IsDir;
        Byte IsAnti;
        Byte CrcDefined;
        Byte MTimeDefined;
        Byte AttribDefined;
} CSzFileItem;

void SzFile_Init(CSzFileItem *p);

typedef struct {
        UInt64 *PackSizes;
        Byte *PackCRCsDefined;
        UInt32 *PackCRCs;
        CSzFolder *Folders;
        CSzFileItem *Files;
        UInt32 NumPackStreams;
        UInt32 NumFolders;
        UInt32 NumFiles;
} CSzAr;

void SzAr_Init(CSzAr *p);
void SzAr_Free(CSzAr *p, ISzAlloc *alloc);

/*
  SzExtract extracts file from archive

  *outBuffer must be 0 before first call for each new archive.

  Extracting cache:
    If you need to decompress more than one file, you can send
    these values from previous call:
      *blockIndex,
      *outBuffer,
      *outBufferSize
    You can consider "*outBuffer" as cache of solid block. If your archive is solid,
    it will increase decompression speed.

    If you use external function, you can declare these 3 cache variables
    (blockIndex, outBuffer, outBufferSize) as static in that external function.

    Free *outBuffer and set *outBuffer to 0, if you want to flush cache.
*/

typedef struct {
        CSzAr db;

        UInt64 startPosAfterHeader;
        UInt64 dataPos;

        UInt32 *FolderStartPackStreamIndex;
        UInt64 *PackStreamStartPositions;
        UInt32 *FolderStartFileIndex;
        UInt32 *FileIndexToFolderIndexMap;

        size_t *FileNameOffsets; /* in 2-byte steps */
        CBuf FileNames;          /* UTF-16-LE */
} CSzArEx;

void SzArEx_Init(CSzArEx *p);
void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc);
UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);

/*
if dest == NULL, the return value specifies the required size of the buffer,
  in 16-bit characters, including the null-terminating character.
if dest != NULL, the return value specifies the number of 16-bit characters that
  are written to the dest, including the null-terminating character. */

size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest);

SRes SzArEx_Extract(const CSzArEx *db, ILookInStream *inStream, UInt32 fileIndex, /* index of file
                                                                                     */
                    UInt32 *blockIndex,       /* index of solid block */
                    Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with
                                                 allocMain) */
                    size_t *outBufferSize,    /* buffer size for output buffer */
                    size_t *offset,           /* offset of stream for required file in *outBuffer */
                    size_t *outSizeProcessed, /* size of file in *outBuffer */
                    ISzAlloc *allocMain, ISzAlloc *allocTemp);

/*
SzArEx_Open Errors:
SZ_ERROR_NO_ARCHIVE
SZ_ERROR_ARCHIVE
SZ_ERROR_UNSUPPORTED
SZ_ERROR_MEM
SZ_ERROR_CRC
SZ_ERROR_INPUT_EOF
SZ_ERROR_FAIL
*/

SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *allocTemp);

EXTERN_C_END

#endif