/* 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
