/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et tw=80 : */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#if !defined(__nsHTTPCompressConv__h__)
#define __nsHTTPCompressConv__h__ 1

#include "nsIStreamConverter.h"
#include "nsICompressConvStats.h"
#include "nsIThreadRetargetableStreamListener.h"
#include "nsCOMPtr.h"
#include "nsAutoPtr.h"
#include "mozilla/Atomics.h"
#include "mozilla/Mutex.h"

#include "zlib.h"

// brotli includes
#undef assert
#include "assert.h"
#include "state.h"

class nsIStringInputStream;

#define NS_HTTPCOMPRESSCONVERTER_CID                    \
  {                                                     \
    /* 66230b2b-17fa-4bd3-abf4-07986151022d */          \
    0x66230b2b,                                         \
      0x17fa,                                           \
      0x4bd3,                                           \
      {0xab, 0xf4, 0x07, 0x98, 0x61, 0x51, 0x02, 0x2d}  \
  }

#define HTTP_DEFLATE_TYPE "deflate"
#define HTTP_GZIP_TYPE "gzip"
#define HTTP_X_GZIP_TYPE "x-gzip"
#define HTTP_COMPRESS_TYPE "compress"
#define HTTP_X_COMPRESS_TYPE "x-compress"
#define HTTP_BROTLI_TYPE "br"
#define HTTP_IDENTITY_TYPE "identity"
#define HTTP_UNCOMPRESSED_TYPE "uncompressed"

namespace mozilla {
namespace net {

typedef enum {
  HTTP_COMPRESS_GZIP,
  HTTP_COMPRESS_DEFLATE,
  HTTP_COMPRESS_COMPRESS,
  HTTP_COMPRESS_BROTLI,
  HTTP_COMPRESS_IDENTITY
} CompressMode;

class BrotliWrapper {
public:
  BrotliWrapper()
      : mTotalOut(0),
        mStatus(NS_OK),
        mBrotliStateIsStreamEnd(false),
        mRequest(nullptr),
        mContext(nullptr),
        mSourceOffset(0) {
    BrotliDecoderStateInit(&mState, 0, 0, 0);
  }
  ~BrotliWrapper() { BrotliDecoderStateCleanup(&mState); }

  BrotliDecoderState mState;
  Atomic<size_t, Relaxed> mTotalOut;
  nsresult mStatus;
  Atomic<bool, Relaxed> mBrotliStateIsStreamEnd;

  nsIRequest* mRequest;
  nsISupports* mContext;
  uint64_t mSourceOffset;
};

class nsHTTPCompressConv : public nsIStreamConverter,
                           public nsICompressConvStats,
                           public nsIThreadRetargetableStreamListener {
public:
  // nsISupports methods
  NS_DECL_THREADSAFE_ISUPPORTS
  NS_DECL_NSIREQUESTOBSERVER
  NS_DECL_NSISTREAMLISTENER
  NS_DECL_NSICOMPRESSCONVSTATS
  NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER

  // nsIStreamConverter methods
  NS_DECL_NSISTREAMCONVERTER

  nsHTTPCompressConv();

private:
  virtual ~nsHTTPCompressConv();

  nsCOMPtr<nsIStreamListener> mListener;  // this guy gets the converted data via his OnDataAvailable ()
  Atomic<CompressMode, Relaxed> mMode;

  unsigned char* mOutBuffer;
  unsigned char* mInpBuffer;

  uint32_t mOutBufferLen;
  uint32_t mInpBufferLen;

  nsAutoPtr<BrotliWrapper> mBrotli;

  nsCOMPtr<nsIStringInputStream> mStream;

  static nsresult BrotliHandler(nsIInputStream* stream,
                                void* closure,
                                const char* dataIn,
                                uint32_t,
                                uint32_t avail,
                                uint32_t* countRead);

  nsresult do_OnDataAvailable(nsIRequest* request,
                              nsISupports* aContext,
                              uint64_t aSourceOffset,
                              const char* buffer,
                              uint32_t aCount);

  bool mCheckHeaderDone;
  Atomic<bool> mStreamEnded;
  bool mStreamInitialized;
  bool mDummyStreamInitialised;
  bool mFailUncleanStops;

  z_stream d_stream;
  unsigned mLen, hMode, mSkipCount, mFlags;

  uint32_t check_header(nsIInputStream* iStr, uint32_t streamLen, nsresult* rv);

  Atomic<uint32_t, Relaxed> mDecodedDataLength;

  mutable mozilla::Mutex mMutex;
};

} // namespace net
} // namespace mozilla

#endif