/**
* 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
 *
 *      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 IOTDB_COLUMN_H
#define IOTDB_COLUMN_H

#include <vector>
#include <memory>
#include <map>
#include <stdexcept>

#include "Common.h"
#include "ColumnDecoder.h"

enum class ColumnEncoding : uint8_t {
    ByteArray,
    Int32Array,
    Int64Array,
    BinaryArray,
    Rle
};

class Binary {
public:
    explicit Binary(std::vector<uint8_t> data) : data_(std::move(data)) {
    }

    const std::vector<uint8_t>& getData() const { return data_; }

    std::string getStringValue() const {
        return {data_.begin(), data_.end()};
    }

private:
    std::vector<uint8_t> data_;
};


const std::map<ColumnEncoding, std::shared_ptr<ColumnDecoder>> kEncodingToDecoder = {
    {ColumnEncoding::Int32Array, std::make_shared<Int32ArrayColumnDecoder>()},
    {ColumnEncoding::Int64Array, std::make_shared<Int64ArrayColumnDecoder>()},
    {ColumnEncoding::ByteArray, std::make_shared<ByteArrayColumnDecoder>()},
    {ColumnEncoding::BinaryArray, std::make_shared<BinaryArrayColumnDecoder>()},
    {ColumnEncoding::Rle, std::make_shared<RunLengthColumnDecoder>()}
};

const std::map<uint8_t, ColumnEncoding> kByteToEncoding = {
    {0, ColumnEncoding::ByteArray},
    {1, ColumnEncoding::Int32Array},
    {2, ColumnEncoding::Int64Array},
    {3, ColumnEncoding::BinaryArray},
    {4, ColumnEncoding::Rle}
};

inline std::shared_ptr<ColumnDecoder> getColumnDecoder(ColumnEncoding encoding) {
    auto it = kEncodingToDecoder.find(encoding);
    if (it == kEncodingToDecoder.end()) {
        throw IoTDBException("Unsupported column encoding");
    }
    return it->second;
}

inline ColumnEncoding getColumnEncodingByByte(uint8_t b) {
    auto it = kByteToEncoding.find(b);
    if (it == kByteToEncoding.end()) {
        throw IoTDBException("Invalid encoding value: " + std::to_string(b));
    }
    return it->second;
}

class Column {
public:
    virtual ~Column() = default;

    virtual TSDataType::TSDataType getDataType() const = 0;
    virtual ColumnEncoding getEncoding() const = 0;

    virtual bool getBoolean(int32_t position) const {
        throw IoTDBException("Unsupported operation: getBoolean");
    }

    virtual int32_t getInt(int32_t position) const {
        throw IoTDBException("Unsupported operation: getInt");
    }

    virtual int64_t getLong(int32_t position) const {
        throw IoTDBException("Unsupported operation: getLong");
    }

    virtual float getFloat(int32_t position) const {
        throw IoTDBException("Unsupported operation: getFloat");
    }

    virtual double getDouble(int32_t position) const {
        throw IoTDBException("Unsupported operation: getDouble");
    }

    virtual std::shared_ptr<Binary> getBinary(int32_t position) const {
        throw IoTDBException("Unsupported operation: getBinary");
    }

    virtual std::vector<bool> getBooleans() const {
        throw IoTDBException("Unsupported operation: getBooleans");
    }

    virtual std::vector<int32_t> getInts() const {
        throw IoTDBException("Unsupported operation: getInts");
    }

    virtual std::vector<int64_t> getLongs() const {
        throw IoTDBException("Unsupported operation: getLongs");
    }

    virtual std::vector<float> getFloats() const {
        throw IoTDBException("Unsupported operation: getFloats");
    }

    virtual std::vector<double> getDoubles() const {
        throw IoTDBException("Unsupported operation: getDoubles");
    }

    virtual std::vector<std::shared_ptr<Binary>> getBinaries() const {
        throw IoTDBException("Unsupported operation: getBinaries");
    }

    virtual bool mayHaveNull() const = 0;
    virtual bool isNull(int32_t position) const = 0;
    virtual std::vector<bool> isNulls() const = 0;

    virtual int32_t getPositionCount() const = 0;
};

class TimeColumn : public Column {
public:
    TimeColumn(int32_t arrayOffset, int32_t positionCount, const std::vector<int64_t>& values);

    TSDataType::TSDataType getDataType() const override;
    ColumnEncoding getEncoding() const override;

    int64_t getLong(int32_t position) const override;

    bool mayHaveNull() const override;
    bool isNull(int32_t position) const override;
    std::vector<bool> isNulls() const override;

    int32_t getPositionCount() const override;

    int64_t getStartTime() const;
    int64_t getEndTime() const;

    const std::vector<int64_t>& getTimes() const;
    std::vector<int64_t> getLongs() const override;

private:
    int32_t arrayOffset_;
    int32_t positionCount_;
    std::vector<int64_t> values_;
};

class BinaryColumn : public Column {
public:
    BinaryColumn(int32_t arrayOffset, int32_t positionCount,
                 const std::vector<bool>& valueIsNull, const std::vector<std::shared_ptr<Binary>>& values);

    TSDataType::TSDataType getDataType() const override;
    ColumnEncoding getEncoding() const override;

    std::shared_ptr<Binary> getBinary(int32_t position) const override;
    std::vector<std::shared_ptr<Binary>> getBinaries() const override;

    bool mayHaveNull() const override;
    bool isNull(int32_t position) const override;
    std::vector<bool> isNulls() const override;

    int32_t getPositionCount() const override;

private:
    int32_t arrayOffset_;
    int32_t positionCount_;
    std::vector<bool> valueIsNull_;
    std::vector<std::shared_ptr<Binary>> values_;
};

class IntColumn : public Column {
public:
    IntColumn(int32_t arrayOffset, int32_t positionCount,
              const std::vector<bool>& valueIsNull, const std::vector<int32_t>& values);

    TSDataType::TSDataType getDataType() const override;
    ColumnEncoding getEncoding() const override;

    int32_t getInt(int32_t position) const override;
    std::vector<int32_t> getInts() const override;

    bool mayHaveNull() const override;
    bool isNull(int32_t position) const override;
    std::vector<bool> isNulls() const override;

    int32_t getPositionCount() const override;

private:
    int32_t arrayOffset_;
    int32_t positionCount_;
    std::vector<bool> valueNull_;
    std::vector<int32_t> values_;
};

class FloatColumn : public Column {
public:
    FloatColumn(int32_t arrayOffset, int32_t positionCount,
                const std::vector<bool>& valueIsNull, const std::vector<float>& values);

    TSDataType::TSDataType getDataType() const override;
    ColumnEncoding getEncoding() const override;

    float getFloat(int32_t position) const override;
    std::vector<float> getFloats() const override;

    bool mayHaveNull() const override;
    bool isNull(int32_t position) const override;
    std::vector<bool> isNulls() const override;

    int32_t getPositionCount() const override;

private:
    int32_t arrayOffset_;
    int32_t positionCount_;
    std::vector<bool> valueIsNull_;
    std::vector<float> values_;
};

class LongColumn : public Column {
public:
    LongColumn(int32_t arrayOffset, int32_t positionCount,
               const std::vector<bool>& valueIsNull, const std::vector<int64_t>& values);

    TSDataType::TSDataType getDataType() const override;
    ColumnEncoding getEncoding() const override;

    int64_t getLong(int32_t position) const override;
    std::vector<int64_t> getLongs() const override;

    bool mayHaveNull() const override;
    bool isNull(int32_t position) const override;
    std::vector<bool> isNulls() const override;

    int32_t getPositionCount() const override;

private:
    int32_t arrayOffset_;
    int32_t positionCount_;
    std::vector<bool> valueIsNull_;
    std::vector<int64_t> values_;
};

class DoubleColumn : public Column {
public:
    DoubleColumn(int32_t arrayOffset, int32_t positionCount,
                 const std::vector<bool>& valueIsNull, const std::vector<double>& values);

    TSDataType::TSDataType getDataType() const override;
    ColumnEncoding getEncoding() const override;

    double getDouble(int32_t position) const override;
    std::vector<double> getDoubles() const override;

    bool mayHaveNull() const override;
    bool isNull(int32_t position) const override;
    std::vector<bool> isNulls() const override;

    int32_t getPositionCount() const override;

private:
    int32_t arrayOffset_;
    int32_t positionCount_;
    std::vector<bool> valueIsNull_;
    std::vector<double> values_;
};

class BooleanColumn : public Column {
public:
    BooleanColumn(int32_t arrayOffset, int32_t positionCount,
                  const std::vector<bool>& valueIsNull, const std::vector<bool>& values);

    TSDataType::TSDataType getDataType() const override;
    ColumnEncoding getEncoding() const override;

    bool getBoolean(int32_t position) const override;
    std::vector<bool> getBooleans() const override;

    bool mayHaveNull() const override;
    bool isNull(int32_t position) const override;
    std::vector<bool> isNulls() const override;

    int32_t getPositionCount() const override;

private:
    int32_t arrayOffset_;
    int32_t positionCount_;
    std::vector<bool> valueIsNull_;
    std::vector<bool> values_;
};

class RunLengthEncodedColumn : public Column {
public:
    RunLengthEncodedColumn(std::shared_ptr<Column> value, int32_t positionCount);

    std::shared_ptr<Column> getValue() const;

    TSDataType::TSDataType getDataType() const override;
    ColumnEncoding getEncoding() const override;

    bool getBoolean(int32_t position) const override;
    int32_t getInt(int32_t position) const override;
    int64_t getLong(int32_t position) const override;
    float getFloat(int32_t position) const override;
    double getDouble(int32_t position) const override;
    std::shared_ptr<Binary> getBinary(int32_t position) const override;

    std::vector<bool> getBooleans() const override;
    std::vector<int32_t> getInts() const override;
    std::vector<int64_t> getLongs() const override;
    std::vector<float> getFloats() const override;
    std::vector<double> getDoubles() const override;
    std::vector<std::shared_ptr<Binary>> getBinaries() const override;

    bool mayHaveNull() const override;
    bool isNull(int32_t position) const override;
    std::vector<bool> isNulls() const override;

    int32_t getPositionCount() const override;

private:
    std::shared_ptr<Column> value_;
    int32_t positionCount_;
};

#endif