/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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
 *
 *     https://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.
 */

#include "Encoder.hh"
#include "Zigzag.hh"
#include <array>

namespace avro {

using std::make_shared;

class BinaryEncoder : public Encoder {
    StreamWriter out_;

    void init(OutputStream &os) final;
    void flush() final;
    int64_t byteCount() const final;
    void encodeNull() final;
    void encodeBool(bool b) final;
    void encodeInt(int32_t i) final;
    void encodeLong(int64_t l) final;
    void encodeFloat(float f) final;
    void encodeDouble(double d) final;
    void encodeString(const std::string &s) final;
    void encodeBytes(const uint8_t *bytes, size_t len) final;
    void encodeFixed(const uint8_t *bytes, size_t len) final;
    void encodeEnum(size_t e) final;
    void arrayStart() final;
    void arrayEnd() final;
    void mapStart() final;
    void mapEnd() final;
    void setItemCount(size_t count) final;
    void startItem() final;
    void encodeUnionIndex(size_t e) final;

    void doEncodeLong(int64_t l);
};

EncoderPtr binaryEncoder() {
    return make_shared<BinaryEncoder>();
}

void BinaryEncoder::init(OutputStream &os) {
    out_.reset(os);
}

void BinaryEncoder::flush() {
    out_.flush();
}

void BinaryEncoder::encodeNull() {
}

void BinaryEncoder::encodeBool(bool b) {
    out_.write(b ? 1 : 0);
}

void BinaryEncoder::encodeInt(int32_t i) {
    doEncodeLong(i);
}

void BinaryEncoder::encodeLong(int64_t l) {
    doEncodeLong(l);
}

void BinaryEncoder::encodeFloat(float f) {
    const auto *p = reinterpret_cast<const uint8_t *>(&f);
    out_.writeBytes(p, sizeof(float));
}

void BinaryEncoder::encodeDouble(double d) {
    const auto *p = reinterpret_cast<const uint8_t *>(&d);
    out_.writeBytes(p, sizeof(double));
}

void BinaryEncoder::encodeString(const std::string &s) {
    doEncodeLong(s.size());
    out_.writeBytes(reinterpret_cast<const uint8_t *>(s.c_str()), s.size());
}

void BinaryEncoder::encodeBytes(const uint8_t *bytes, size_t len) {
    doEncodeLong(len);
    out_.writeBytes(bytes, len);
}

void BinaryEncoder::encodeFixed(const uint8_t *bytes, size_t len) {
    out_.writeBytes(bytes, len);
}

void BinaryEncoder::encodeEnum(size_t e) {
    doEncodeLong(e);
}

void BinaryEncoder::arrayStart() {
}

void BinaryEncoder::arrayEnd() {
    doEncodeLong(0);
}

void BinaryEncoder::mapStart() {
}

void BinaryEncoder::mapEnd() {
    doEncodeLong(0);
}

void BinaryEncoder::setItemCount(size_t count) {
    if (count == 0) {
        throw Exception("Count cannot be zero");
    }
    doEncodeLong(count);
}

void BinaryEncoder::startItem() {
}

void BinaryEncoder::encodeUnionIndex(size_t e) {
    doEncodeLong(e);
}

int64_t BinaryEncoder::byteCount() const {
    return out_.byteCount();
}

void BinaryEncoder::doEncodeLong(int64_t l) {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
    std::array<uint8_t, 10> bytes;
    auto size = encodeInt64(l, bytes);
    out_.writeBytes(bytes.data(), size);
}
} // namespace avro