// 7z/Out.h

#ifndef __7Z_OUT_H
#define __7Z_OUT_H

#include "7zHeader.h"
#include "7zItem.h"
#include "7zCompressionMode.h"
#include "7zEncode.h"

#include "../../Common/OutBuffer.h"
#include "../../../Common/DynamicBuffer.h"

namespace NArchive {
namespace N7z {

class CWriteBufferLoc
{
  Byte *_data;
  size_t _size;
  size_t _pos;
public:
  CWriteBufferLoc(): _size(0), _pos(0) {}
  void Init(Byte *data, size_t size)  
  { 
    _pos = 0;
    _data = data;
    _size = size; 
  }
  HRESULT Write(const void *data, size_t size)
  {
    if (_pos + size > _size)
      return E_FAIL;
    memmove(_data + _pos, data, size);
    _pos += size;
    return S_OK; 
  }
};

class CWriteDynamicBuffer
{
  CByteDynamicBuffer _buffer;
  size_t _pos;
public:
  CWriteDynamicBuffer(): _pos(0) {}
  void Init()  
  { 
    _pos = 0;
  }
  void Write(const void *data, size_t size)
  {
    if (_pos + size > _buffer.GetCapacity())
      _buffer.EnsureCapacity(_pos + size);
    memmove(((Byte *)_buffer) +_pos, data, size);
    _pos += size;
  }
  operator Byte *() { return (Byte *)_buffer; };
  operator const Byte *() const { return (const Byte *)_buffer; };
  size_t GetSize() const { return _pos; }
};

struct CHeaderOptions
{
  // bool UseAdditionalHeaderStreams;
  bool CompressMainHeader;
  bool WriteModified;
  bool WriteCreated;
  bool WriteAccessed;

  CHeaderOptions(): 
      // UseAdditionalHeaderStreams(false), 
      CompressMainHeader(true),
      WriteModified(true),
      WriteCreated(false),
      WriteAccessed(false) {} 
};

class COutArchive
{
  UInt64 _prefixHeaderPos;

  HRESULT WriteDirect(const void *data, UInt32 size);
  HRESULT WriteDirectByte(Byte b) { return WriteDirect(&b, 1); }
  HRESULT WriteDirectUInt32(UInt32 value);
  HRESULT WriteDirectUInt64(UInt64 value);
  
  HRESULT WriteBytes(const void *data, size_t size);
  HRESULT WriteBytes(const CByteBuffer &data);
  HRESULT WriteByte(Byte b);
  HRESULT WriteUInt32(UInt32 value);
  HRESULT WriteNumber(UInt64 value);
  HRESULT WriteID(UInt64 value) { return WriteNumber(value); }

  HRESULT WriteFolder(const CFolder &folder);
  HRESULT WriteFileHeader(const CFileItem &itemInfo);
  HRESULT WriteBoolVector(const CBoolVector &boolVector);
  HRESULT WriteHashDigests(
      const CRecordVector<bool> &digestsDefined,
      const CRecordVector<UInt32> &hashDigests);

  HRESULT WritePackInfo(
      UInt64 dataOffset,
      const CRecordVector<UInt64> &packSizes,
      const CRecordVector<bool> &packCRCsDefined,
      const CRecordVector<UInt32> &packCRCs);

  HRESULT WriteUnPackInfo(const CObjectVector<CFolder> &folders);

  HRESULT WriteSubStreamsInfo(
      const CObjectVector<CFolder> &folders,
      const CRecordVector<CNum> &numUnPackStreamsInFolders,
      const CRecordVector<UInt64> &unPackSizes,
      const CRecordVector<bool> &digestsDefined,
      const CRecordVector<UInt32> &hashDigests);

  /*
  HRESULT WriteStreamsInfo(
      UInt64 dataOffset,
      const CRecordVector<UInt64> &packSizes,
      const CRecordVector<bool> &packCRCsDefined,
      const CRecordVector<UInt32> &packCRCs,
      bool externalFolders,
      UInt64 externalFoldersStreamIndex,
      const CObjectVector<CFolder> &folders,
      const CRecordVector<CNum> &numUnPackStreamsInFolders,
      const CRecordVector<UInt64> &unPackSizes,
      const CRecordVector<bool> &digestsDefined,
      const CRecordVector<UInt32> &hashDigests);
  */


  HRESULT WriteTime(const CObjectVector<CFileItem> &files, Byte type);

  HRESULT EncodeStream(
      DECL_EXTERNAL_CODECS_LOC_VARS
      CEncoder &encoder, const Byte *data, size_t dataSize,
      CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders);
  HRESULT EncodeStream(
      DECL_EXTERNAL_CODECS_LOC_VARS
      CEncoder &encoder, const CByteBuffer &data, 
      CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders);
  HRESULT WriteHeader(
      const CArchiveDatabase &database,
      const CHeaderOptions &headerOptions,
      UInt64 &headerOffset);
  
  bool _mainMode;

  bool _dynamicMode;

  bool _countMode;
  size_t _countSize;
  COutBuffer _outByte;
  CWriteBufferLoc _outByte2;
  CWriteDynamicBuffer _dynamicBuffer;
  UInt32 _crc;

  #ifdef _7Z_VOL
  bool _endMarker;
  #endif

  HRESULT WriteSignature();
  #ifdef _7Z_VOL
  HRESULT WriteFinishSignature();
  #endif
  HRESULT WriteStartHeader(const CStartHeader &h);
  #ifdef _7Z_VOL
  HRESULT WriteFinishHeader(const CFinishHeader &h);
  #endif
  CMyComPtr<IOutStream> Stream;
public:

  COutArchive() { _outByte.Create(1 << 16); }
  CMyComPtr<ISequentialOutStream> SeqStream;
  HRESULT Create(ISequentialOutStream *stream, bool endMarker);
  void Close();
  HRESULT SkeepPrefixArchiveHeader();
  HRESULT WriteDatabase(
      DECL_EXTERNAL_CODECS_LOC_VARS
      const CArchiveDatabase &database,
      const CCompressionMethodMode *options, 
      const CHeaderOptions &headerOptions);

  #ifdef _7Z_VOL
  static UInt32 GetVolHeadersSize(UInt64 dataSize, int nameLength = 0, bool props = false);
  static UInt64 GetVolPureSize(UInt64 volSize, int nameLength = 0, bool props = false);
  #endif

};

}}

#endif