/*

 * Copyright (c) 2021 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef PKG_ALGORITHM_LZ4_H

#define PKG_ALGORITHM_LZ4_H



#include "lz4.h"

#include "lz4frame.h"

#include "lz4hc.h"

#include "pkg_algorithm.h"

#include "pkg_stream.h"

#include "pkg_utils.h"



namespace Hpackage {

struct PkgBufferMessage {

    PkgAlgorithmContext context {{0, 0}, {0, 0}, 0, 0};

    PkgBuffer inBuffer {};

    PkgBuffer outBuffer {};

    size_t inBuffSize {};

    size_t outBuffSize {};

};



class PkgAlgorithmLz4 : public PkgAlgorithm {

public:

    static const uint32_t LZ4S_MAGIC_NUMBER = 0x184D2204;

    static const uint32_t LZ4S_SKIPPABLE0 = 0x184D2A50;

    static const uint32_t LZ4S_SKIPPABLE_MASK = 0xFFFFFFF0;

    static const uint32_t LZ4B_MAGIC_NUMBER = 0x184C2102;

    static const uint32_t LZ4B_BLOCK_SIZE = 1 << 22; // (4M)

    static const uint32_t LZ4S_HEADER_LEN = 20;



    explicit PkgAlgorithmLz4(const Lz4FileInfo &config);



    ~PkgAlgorithmLz4() override {}



    int32_t PackCalculate(const PkgStreamPtr inStream, const PkgStreamPtr outStream,

        PkgBufferMessage &msg, size_t &dataLen, LZ4F_compressionContext_t &ctx);



    int32_t Pack(const PkgStreamPtr inStream, const PkgStreamPtr outStream,

        PkgAlgorithmContext &context) override;



    int32_t UnpackDecode(const PkgStreamPtr inStream, const PkgStreamPtr outStream,

        PkgBufferMessage &msg, size_t &nextToRead, LZ4F_decompressionContext_t &ctx);



    int32_t Unpack(const PkgStreamPtr inStream,

        const PkgStreamPtr outStream, PkgAlgorithmContext &context) override;



    void UpdateFileInfo(PkgManager::FileInfoPtr info) const override;



protected:

    int32_t GetBlockSizeFromBlockId(int32_t id) const

    {

        return (1 << (8 + (2 * id))); // 8,2 : Get block size from block ID

    }

    int32_t GetPackParam(LZ4F_compressionContext_t &ctx, LZ4F_preferences_t &preferences,

        size_t &inBuffSize, size_t &outBuffSize) const;

    int32_t GetUnpackParam(LZ4F_decompressionContext_t &ctx,

        const PkgStreamPtr inStream, size_t &nextToRead, size_t &srcOffset);



    int32_t AdpLz4Compress(const uint8_t *src, uint8_t *dest, uint32_t srcSize, uint32_t dstCapacity) const;



    int32_t AdpLz4Decompress(const uint8_t *src, uint8_t *dest, uint32_t srcSize, uint32_t dstCapacity) const;



protected:

    int8_t compressionLevel_ {0};

    int8_t blockIndependence_ {0};

    int8_t contentChecksumFlag_ {0};

    int8_t blockSizeID_ {0};

    int8_t autoFlush_ {1};

};



class PkgAlgorithmBlockLz4 : public PkgAlgorithmLz4 {

public:

    static const uint32_t LZ4B_REVERSED_LEN = 4;

    explicit PkgAlgorithmBlockLz4(const Lz4FileInfo &config) : PkgAlgorithmLz4(config) {}



    ~PkgAlgorithmBlockLz4() override {}



    int32_t Pack(const PkgStreamPtr inStream,

        const PkgStreamPtr outStream, PkgAlgorithmContext &context) override;



    int32_t PackCalculate(const PkgStreamPtr inStream, const PkgStreamPtr outStream,

        PkgAlgorithmContext &context, PkgBuffer &inBuffer, PkgBuffer &outBuffer);



    int32_t Unpack(const PkgStreamPtr inStream, const PkgStreamPtr outStream,

        PkgAlgorithmContext &context) override;



    int32_t UnpackCalculate(const PkgStreamPtr inStream, const PkgStreamPtr outStream,

        PkgAlgorithmContext &context, int &inBuffSize);

};

} // namespace Hpackage

#endif