/*
 * 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.
 */

#include <ignite/impl/interop/interop_stream_position_guard.h>

#include "ignite/odbc/utility.h"
#include "ignite/odbc/column.h"

namespace
{
    using namespace ignite::impl::interop;
    using namespace ignite::impl::binary;

    bool GetObjectLength(InteropInputStream& stream, int32_t& len)
    {
        InteropStreamPositionGuard<InteropInputStream> guard(stream);

        int8_t hdr = stream.ReadInt8();

        switch (hdr)
        {
            case IGNITE_TYPE_BINARY:
            {
                // Header field + Length field + Object itself + Offset field
                len = 1 + 4 + stream.ReadInt32() + 4;

                break;
            }

            case IGNITE_TYPE_OBJECT:
            {
                int8_t protoVer = stream.ReadInt8();

                if (protoVer != IGNITE_PROTO_VER)
                    return false;

                // Skipping flags, typeId and hash code
                len = stream.ReadInt32(stream.Position() + 2 + 4 + 4);

                break;
            }

            default:
                return false;
        }

        return true;
    }

    /**
     * Read column header and restores position if the column is of
     * complex type.
     * @return Column type header.
     */
    int8_t ReadColumnHeader(InteropInputStream& stream)
    {
        using namespace ignite::impl::binary;

        int32_t headerPos = stream.Position();

        int8_t hdr = stream.ReadInt8();

        // Check if we need to restore position - to read complex types
        // stream should have unread header, but for primitive types it
        // should not.
        switch (hdr)
        {
            case IGNITE_TYPE_BYTE:
            case IGNITE_TYPE_SHORT:
            case IGNITE_TYPE_CHAR:
            case IGNITE_TYPE_INT:
            case IGNITE_TYPE_LONG:
            case IGNITE_TYPE_FLOAT:
            case IGNITE_TYPE_DOUBLE:
            case IGNITE_TYPE_BOOL:
            case IGNITE_HDR_NULL:
            case IGNITE_TYPE_ARRAY_BYTE:
            {
                // No-op.
                break;
            }

            default:
            {
                // Restoring position.
                stream.Position(headerPos);
                break;
            }
        }

        return hdr;
    }
}

namespace ignite
{
    namespace odbc
    {
        Column::Column() :
            type(0), startPos(-1), endPos(-1), offset(0), size(0)
        {
            // No-op.
        }

        Column::Column(const Column& other) :
            type(other.type), startPos(other.startPos), endPos(other.endPos),
            offset(other.offset), size(other.size)
        {
            // No-op.
        }

        Column& Column::operator=(const Column& other)
        {
            type = other.type;
            startPos = other.startPos;
            endPos = other.endPos;
            offset = other.offset;
            size = other.size;

            return *this;
        }

        Column::~Column()
        {
            // No-op.
        }

        Column::Column(BinaryReaderImpl& reader) :
            type(0), startPos(-1), endPos(-1), offset(0), size(0)
        {
            InteropInputStream* stream = reader.GetStream();

            if (!stream)
                return;

            InteropStreamPositionGuard<InteropInputStream> guard(*stream);

            int32_t sizeTmp = 0;

            int8_t hdr = ReadColumnHeader(*stream);

            int32_t startPosTmp = stream->Position();

            switch (hdr)
            {
                case IGNITE_HDR_NULL:
                {
                    sizeTmp = 1;

                    break;
                }

                case IGNITE_TYPE_BYTE:
                {
                    reader.ReadInt8();

                    sizeTmp = 1;

                    break;
                }

                case IGNITE_TYPE_BOOL:
                {
                    reader.ReadBool();

                    sizeTmp = 1;

                    break;
                }

                case IGNITE_TYPE_SHORT:
                case IGNITE_TYPE_CHAR:
                {
                    reader.ReadInt16();

                    sizeTmp = 2;

                    break;
                }

                case IGNITE_TYPE_FLOAT:
                {
                    reader.ReadFloat();

                    sizeTmp = 4;

                    break;
                }

                case IGNITE_TYPE_INT:
                {
                    reader.ReadInt32();

                    sizeTmp = 4;

                    break;
                }

                case IGNITE_TYPE_DOUBLE:
                {
                    reader.ReadDouble();

                    sizeTmp = 8;

                    break;
                }

                case IGNITE_TYPE_LONG:
                {
                    reader.ReadInt64();

                    sizeTmp = 8;

                    break;
                }

                case IGNITE_TYPE_STRING:
                {
                    std::string str;
                    utility::ReadString(reader, str);

                    sizeTmp = static_cast<int32_t>(str.size());

                    break;
                }

                case IGNITE_TYPE_UUID:
                {
                    reader.ReadGuid();

                    sizeTmp = 16;

                    break;
                }

                case IGNITE_TYPE_BINARY:
                case IGNITE_TYPE_OBJECT:
                {
                    int32_t len;

                    if (!GetObjectLength(*stream, len))
                        return;

                    sizeTmp = len;

                    stream->Position(stream->Position() + len);

                    break;
                }

                case IGNITE_TYPE_DECIMAL:
                {
                    common::Decimal res;

                    utility::ReadDecimal(reader, res);

                    sizeTmp = res.GetMagnitudeLength() + 8;

                    break;
                }

                case IGNITE_TYPE_DATE:
                {
                    reader.ReadDate();

                    sizeTmp = 8;

                    break;
                }

                case IGNITE_TYPE_TIME:
                {
                    reader.ReadTime();

                    sizeTmp = 8;

                    break;
                }

                case IGNITE_TYPE_TIMESTAMP:
                {
                    reader.ReadTimestamp();

                    sizeTmp = 12;

                    break;
                }

                case IGNITE_TYPE_ARRAY_BYTE:
                {
                    sizeTmp = reader.ReadInt32();
                    assert(sizeTmp >= 0);

                    startPosTmp = stream->Position();
                    stream->Position(stream->Position() + sizeTmp);

                    break;
                }

                default:
                {
                    // This is a fail case.
                    assert(false);
                    return;
                }
            }

            type = hdr;
            startPos = startPosTmp;
            endPos = stream->Position();
            size = sizeTmp;
        }

        app::ConversionResult::Type Column::ReadToBuffer(BinaryReaderImpl& reader, app::ApplicationDataBuffer& dataBuf)
        {
            if (!IsValid())
                return app::ConversionResult::AI_FAILURE;

            if (GetUnreadDataLength() == 0)
            {
                dataBuf.PutNull();

                return app::ConversionResult::AI_NO_DATA;
            }

            InteropInputStream* stream = reader.GetStream();

            if (!stream)
                return app::ConversionResult::AI_FAILURE;

            InteropStreamPositionGuard<InteropInputStream> guard(*stream);

            stream->Position(startPos);

            app::ConversionResult::Type convRes = app::ConversionResult::AI_SUCCESS;

            switch (type)
            {
                case IGNITE_TYPE_BYTE:
                {
                    convRes = dataBuf.PutInt8(reader.ReadInt8());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_SHORT:
                case IGNITE_TYPE_CHAR:
                {
                    convRes = dataBuf.PutInt16(reader.ReadInt16());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_INT:
                {
                    convRes = dataBuf.PutInt32(reader.ReadInt32());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_LONG:
                {
                    convRes = dataBuf.PutInt64(reader.ReadInt64());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_FLOAT:
                {
                    convRes = dataBuf.PutFloat(reader.ReadFloat());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_DOUBLE:
                {
                    convRes = dataBuf.PutDouble(reader.ReadDouble());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_BOOL:
                {
                    convRes = dataBuf.PutInt8(reader.ReadBool() ? 1 : 0);

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_STRING:
                {
                    std::string str;
                    utility::ReadString(reader, str);

                    int32_t written = 0;
                    convRes = dataBuf.PutString(str.substr(offset), written);

                    IncreaseOffset(written);

                    break;
                }

                case IGNITE_TYPE_UUID:
                {
                    Guid guid = reader.ReadGuid();

                    convRes = dataBuf.PutGuid(guid);

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_HDR_NULL:
                {
                    convRes = dataBuf.PutNull();

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_BINARY:
                case IGNITE_TYPE_OBJECT:
                {
                    int32_t len;

                    if (!GetObjectLength(*stream, len))
                        return app::ConversionResult::AI_FAILURE;

                    std::vector<int8_t> data(len);

                    stream->ReadInt8Array(&data[0], static_cast<int32_t>(data.size()));

                    int32_t written = 0;
                    convRes = dataBuf.PutBinaryData(data.data() + offset,
                        static_cast<size_t>(len - offset), written);

                    IncreaseOffset(written);

                    break;
                }

                case IGNITE_TYPE_DECIMAL:
                {
                    common::Decimal res;

                    utility::ReadDecimal(reader, res);

                    convRes = dataBuf.PutDecimal(res);

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_DATE:
                {
                    Date date = reader.ReadDate();

                    convRes = dataBuf.PutDate(date);

                    break;
                }

                case IGNITE_TYPE_TIMESTAMP:
                {
                    Timestamp ts = reader.ReadTimestamp();

                    convRes = dataBuf.PutTimestamp(ts);

                    break;
                }

                case IGNITE_TYPE_TIME:
                {
                    Time time = reader.ReadTime();

                    convRes = dataBuf.PutTime(time);

                    break;
                }

                case IGNITE_TYPE_ARRAY_BYTE:
                {
                    stream->Position(startPos + offset);
                    int32_t maxRead = std::min(GetUnreadDataLength(), static_cast<int32_t>(dataBuf.GetSize()));
                    std::vector<int8_t> data(maxRead);

                    stream->ReadInt8Array(&data[0], static_cast<int32_t>(data.size()));

                    int32_t written = 0;
                    convRes = dataBuf.PutBinaryData(data.data(), data.size(), written);

                    IncreaseOffset(written);
                    break;
                }

                default:
                    return app::ConversionResult::AI_UNSUPPORTED_CONVERSION;
            }

            return convRes;
        }

        void Column::IncreaseOffset(int32_t value)
        {
            offset += value;

            if (offset > size)
                offset = size;
        }
    }
}