/*
 *
 *    Copyright (c) 2020 Project CHIP Authors
 *    Copyright (c) 2013-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    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.
 */

/**
 *    @file
 *      This file implements an object for reading Abstract Syntax
 *      Notation One (ASN.1) encoded data.
 *
 */

#include <ctype.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include <asn1/ASN1.h>

namespace chip {
namespace ASN1 {

void ASN1Reader::Init(const uint8_t * buf, uint32_t len)
{
    ResetElementState();
    mBuf              = buf;
    mBufEnd           = buf + len;
    mElemStart        = buf;
    mContainerEnd     = mBufEnd;
    mNumSavedContexts = 0;
}

ASN1_ERROR ASN1Reader::Next()
{
    if (EndOfContents)
        return ASN1_END;

    if (IndefiniteLen)
    {
        return ASN1_ERROR_UNSUPPORTED_ENCODING;
    }
    else
        mElemStart += (mHeadLen + ValueLen);

    ResetElementState();

    if (mElemStart == mContainerEnd)
        return ASN1_END;

    return DecodeHead();
}

ASN1_ERROR ASN1Reader::EnterConstructedType()
{
    if (!Constructed)
        return ASN1_ERROR_INVALID_STATE;

    return EnterContainer(0);
}

ASN1_ERROR ASN1Reader::ExitConstructedType()
{
    return ExitContainer();
}

ASN1_ERROR ASN1Reader::GetConstructedType(const uint8_t *& val, uint32_t & valLen)
{
    if (!Constructed)
        return ASN1_ERROR_INVALID_STATE;

    val    = mElemStart;
    valLen = mHeadLen + ValueLen;

    return ASN1_NO_ERROR;
}
ASN1_ERROR ASN1Reader::EnterEncapsulatedType()
{
    if (Class != kASN1TagClass_Universal || (Tag != kASN1UniversalTag_OctetString && Tag != kASN1UniversalTag_BitString))
        return ASN1_ERROR_INVALID_STATE;

    if (Constructed)
        return ASN1_ERROR_UNSUPPORTED_ENCODING;

    return EnterContainer((Tag == kASN1UniversalTag_BitString) ? 1 : 0);
}

ASN1_ERROR ASN1Reader::ExitEncapsulatedType()
{
    return ExitContainer();
}

ASN1_ERROR ASN1Reader::EnterContainer(uint32_t offset)
{
    if (mNumSavedContexts == kMaxContextDepth)
        return ASN1_ERROR_MAX_DEPTH_EXCEEDED;

    mSavedContexts[mNumSavedContexts].ElemStart     = mElemStart;
    mSavedContexts[mNumSavedContexts].HeadLen       = mHeadLen;
    mSavedContexts[mNumSavedContexts].ValueLen      = ValueLen;
    mSavedContexts[mNumSavedContexts].IndefiniteLen = IndefiniteLen;
    mSavedContexts[mNumSavedContexts].ContainerEnd  = mContainerEnd;
    mNumSavedContexts++;

    mElemStart = Value + offset;
    if (!IndefiniteLen)
        mContainerEnd = Value + ValueLen;

    ResetElementState();

    return ASN1_NO_ERROR;
}

ASN1_ERROR ASN1Reader::ExitContainer()
{
    if (mNumSavedContexts == 0)
        return ASN1_ERROR_INVALID_STATE;

    ASN1ParseContext & prevContext = mSavedContexts[--mNumSavedContexts];

    if (prevContext.IndefiniteLen)
    {
        return ASN1_ERROR_UNSUPPORTED_ENCODING;
    }
    else
        mElemStart = prevContext.ElemStart + prevContext.HeadLen + prevContext.ValueLen;

    mContainerEnd = prevContext.ContainerEnd;

    ResetElementState();

    return ASN1_NO_ERROR;
}

bool ASN1Reader::IsContained() const
{
    return mNumSavedContexts > 0;
}

ASN1_ERROR ASN1Reader::GetInteger(int64_t & val)
{
    if (Value == nullptr)
        return ASN1_ERROR_INVALID_STATE;
    if (ValueLen < 1)
        return ASN1_ERROR_INVALID_ENCODING;
    if (ValueLen > sizeof(int64_t))
        return ASN1_ERROR_VALUE_OVERFLOW;
    if (mElemStart + mHeadLen + ValueLen > mContainerEnd)
        return ASN1_ERROR_UNDERRUN;
    const uint8_t * p = Value;
    val               = ((*p & 0x80) == 0) ? 0 : -1;
    for (uint32_t i = ValueLen; i > 0; i--, p++)
        val = (val << 8) | *p;
    return ASN1_NO_ERROR;
}

ASN1_ERROR ASN1Reader::GetBoolean(bool & val)
{
    if (Value == nullptr)
        return ASN1_ERROR_INVALID_STATE;
    if (ValueLen != 1)
        return ASN1_ERROR_INVALID_ENCODING;
    if (mElemStart + mHeadLen + ValueLen > mContainerEnd)
        return ASN1_ERROR_UNDERRUN;
    if (*Value == 0)
        val = false;
    else if (*Value == 0xFF)
        val = true;
    else
        return ASN1_ERROR_INVALID_ENCODING;
    return ASN1_NO_ERROR;
}

ASN1_ERROR ASN1Reader::GetUTCTime(ASN1UniversalTime & outTime)
{
    // Supported Encoding: YYMMDDHHMMSSZ

    if (Value == nullptr)
        return ASN1_ERROR_INVALID_STATE;
    if (ValueLen < 1)
        return ASN1_ERROR_INVALID_ENCODING;
    if (mElemStart + mHeadLen + ValueLen > mContainerEnd)
        return ASN1_ERROR_UNDERRUN;

    if (ValueLen != 13 || Value[12] != 'Z')
        return ASN1_ERROR_UNSUPPORTED_ENCODING;

    for (int i = 0; i < 12; i++)
        if (!isdigit(Value[i]))
            return ASN1_ERROR_INVALID_ENCODING;

    outTime.Year   = (Value[0] - '0') * 10 + (Value[1] - '0');
    outTime.Month  = (Value[2] - '0') * 10 + (Value[3] - '0');
    outTime.Day    = (Value[4] - '0') * 10 + (Value[5] - '0');
    outTime.Hour   = (Value[6] - '0') * 10 + (Value[7] - '0');
    outTime.Minute = (Value[8] - '0') * 10 + (Value[9] - '0');
    outTime.Second = (Value[10] - '0') * 10 + (Value[11] - '0');

    if (outTime.Year >= 50)
        outTime.Year += 1900;
    else
        outTime.Year += 2000;

    return ASN1_NO_ERROR;
}

ASN1_ERROR ASN1Reader::GetGeneralizedTime(ASN1UniversalTime & outTime)
{
    // Supported Encoding: YYYYMMDDHHMMSSZ

    if (Value == nullptr)
        return ASN1_ERROR_INVALID_STATE;
    if (ValueLen < 1)
        return ASN1_ERROR_INVALID_ENCODING;
    if (mElemStart + mHeadLen + ValueLen > mContainerEnd)
        return ASN1_ERROR_UNDERRUN;

    if (ValueLen != 15 || Value[14] != 'Z')
        return ASN1_ERROR_UNSUPPORTED_ENCODING;

    for (int i = 0; i < 14; i++)
        if (!isdigit(Value[i]))
            return ASN1_ERROR_INVALID_ENCODING;

    outTime.Year   = (Value[0] - '0') * 1000 + (Value[1] - '0') * 100 + (Value[2] - '0') * 10 + (Value[3] - '0');
    outTime.Month  = (Value[4] - '0') * 10 + (Value[5] - '0');
    outTime.Day    = (Value[6] - '0') * 10 + (Value[7] - '0');
    outTime.Hour   = (Value[8] - '0') * 10 + (Value[9] - '0');
    outTime.Minute = (Value[10] - '0') * 10 + (Value[11] - '0');
    outTime.Second = (Value[12] - '0') * 10 + (Value[13] - '0');

    return ASN1_NO_ERROR;
}

static uint8_t ReverseBits(uint8_t v)
{
    // swap adjacent bits
    v = ((v >> 1) & 0x55) | ((v & 0x55) << 1);
    // swap adjacent bit pairs
    v = ((v >> 2) & 0x33) | ((v & 0x33) << 2);
    // swap nibbles
    v = (v >> 4) | (v << 4);
    return v;
}

ASN1_ERROR ASN1Reader::GetBitString(uint32_t & outVal)
{
    // NOTE: only supports DER encoding.

    if (Value == nullptr)
        return ASN1_ERROR_INVALID_STATE;
    if (ValueLen < 1)
        return ASN1_ERROR_INVALID_ENCODING;
    if (ValueLen > 5)
        return ASN1_ERROR_UNSUPPORTED_ENCODING;
    if (mElemStart + mHeadLen + ValueLen > mContainerEnd)
        return ASN1_ERROR_UNDERRUN;

    if (ValueLen == 1)
        outVal = 0;
    else
    {
        outVal    = ReverseBits(Value[1]);
        int shift = 8;
        for (uint32_t i = 2; i < ValueLen; i++, shift += 8)
            outVal |= (ReverseBits(Value[i]) << shift);
    }

    return ASN1_NO_ERROR;
}

ASN1_ERROR ASN1Reader::DecodeHead()
{
    const uint8_t * p = mElemStart;

    if (p >= mBufEnd)
        return ASN1_ERROR_UNDERRUN;

    Class       = *p & 0xC0;
    Constructed = (*p & 0x20) != 0;

    Tag = *p & 0x1F;
    p++;
    if (Tag == 0x1F)
    {
        Tag = 0;
        do
        {
            if (p >= mBufEnd)
                return ASN1_ERROR_UNDERRUN;
            if ((Tag & 0xFE000000) != 0)
                return ASN1_ERROR_TAG_OVERFLOW;
            Tag = (Tag << 7) | (*p & 0x7F);
            p++;
        } while ((*p & 0x80) != 0);
    }

    if (p >= mBufEnd)
        return ASN1_ERROR_UNDERRUN;

    if ((*p & 0x80) == 0)
    {
        ValueLen      = *p & 0x7F;
        IndefiniteLen = false;
        p++;
    }
    else if (*p == 0x80)
    {
        ValueLen      = 0;
        IndefiniteLen = true;
        p++;
    }
    else
    {
        ValueLen       = 0;
        uint8_t lenLen = *p & 0x7F;
        p++;
        for (; lenLen > 0; lenLen--, p++)
        {
            if (p >= mBufEnd)
                return ASN1_ERROR_UNDERRUN;
            if ((ValueLen & 0xFF000000) != 0)
                return ASN1_ERROR_LENGTH_OVERFLOW;
            ValueLen = (ValueLen << 8) | *p;
        }
        IndefiniteLen = false;
    }

    mHeadLen = p - mElemStart;

    EndOfContents = (Class == kASN1TagClass_Universal && Tag == 0 && Constructed == false && ValueLen == 0);

    Value = p;

    return ASN1_NO_ERROR;
}

void ASN1Reader::ResetElementState()
{
    Class         = 0;
    Tag           = 0;
    Value         = nullptr;
    ValueLen      = 0;
    Constructed   = false;
    IndefiniteLen = false;
    EndOfContents = false;
    mHeadLen      = 0;
}

ASN1_ERROR DumpASN1(ASN1Reader & asn1Parser, const char * prefix, const char * indent)
{
    ASN1_ERROR err = ASN1_NO_ERROR;

    if (indent == nullptr)
        indent = "  ";

    int nestLevel = 0;
    while (true)
    {
        err = asn1Parser.Next();
        if (err != ASN1_NO_ERROR)
        {
            if (err == ASN1_END)
            {
                if (asn1Parser.IsContained())
                {
                    err = asn1Parser.ExitConstructedType();
                    if (err != ASN1_NO_ERROR)
                    {
                        printf("ASN1Reader::ExitConstructedType() failed: %ld\n", (long) err);
                        return err;
                    }
                    nestLevel--;
                    continue;
                }
                else
                    break;
            }
            printf("ASN1Reader::Next() failed: %ld\n", (long) err);
            return err;
        }
        if (prefix != nullptr)
            printf("%s", prefix);
        for (int i = nestLevel; i; i--)
            printf("%s", indent);
        if (asn1Parser.IsEndOfContents())
            printf("END-OF-CONTENTS ");
        else if (asn1Parser.GetClass() == kASN1TagClass_Universal)
            switch (asn1Parser.GetTag())
            {
            case kASN1UniversalTag_Boolean:
                printf("BOOLEAN ");
                break;
            case kASN1UniversalTag_Integer:
                printf("INTEGER ");
                break;
            case kASN1UniversalTag_BitString:
                printf("BIT STRING ");
                break;
            case kASN1UniversalTag_OctetString:
                printf("OCTET STRING ");
                break;
            case kASN1UniversalTag_Null:
                printf("NULL ");
                break;
            case kASN1UniversalTag_ObjectId:
                printf("OBJECT IDENTIFIER ");
                break;
            case kASN1UniversalTag_ObjectDesc:
                printf("OBJECT DESCRIPTOR ");
                break;
            case kASN1UniversalTag_External:
                printf("EXTERNAL ");
                break;
            case kASN1UniversalTag_Real:
                printf("REAL ");
                break;
            case kASN1UniversalTag_Enumerated:
                printf("ENUMERATED ");
                break;
            case kASN1UniversalTag_Sequence:
                printf("SEQUENCE ");
                break;
            case kASN1UniversalTag_Set:
                printf("SET ");
                break;
            case kASN1UniversalTag_UTF8String:
            case kASN1UniversalTag_NumericString:
            case kASN1UniversalTag_PrintableString:
            case kASN1UniversalTag_T61String:
            case kASN1UniversalTag_VideotexString:
            case kASN1UniversalTag_IA5String:
            case kASN1UniversalTag_GraphicString:
            case kASN1UniversalTag_VisibleString:
            case kASN1UniversalTag_GeneralString:
            case kASN1UniversalTag_UniversalString:
                printf("STRING ");
                break;
            case kASN1UniversalTag_UTCTime:
            case kASN1UniversalTag_GeneralizedTime:
                printf("TIME ");
                break;
            default:
                printf("[UNIVERSAL %lu] ", static_cast<unsigned long>(asn1Parser.GetTag()));
                break;
            }
        else if (asn1Parser.GetClass() == kASN1TagClass_Application)
            printf("[APPLICATION %lu] ", static_cast<unsigned long>(asn1Parser.GetTag()));
        else if (asn1Parser.GetClass() == kASN1TagClass_ContextSpecific)
            printf("[%lu] ", static_cast<unsigned long>(asn1Parser.GetTag()));
        else if (asn1Parser.GetClass() == kASN1TagClass_Private)
            printf("[PRIVATE %lu] ", static_cast<unsigned long>(asn1Parser.GetTag()));

        if (asn1Parser.IsConstructed())
            printf("(constructed) ");

        if (asn1Parser.IsIndefiniteLen())
            printf("Length = indefinite\n");
        else
            printf("Length = %ld\n", static_cast<long>(asn1Parser.GetValueLen()));

        if (asn1Parser.IsConstructed())
        {
            err = asn1Parser.EnterConstructedType();
            if (err != ASN1_NO_ERROR)
            {
                printf("ASN1Reader::EnterConstructedType() failed: %ld\n", (long) err);
                return err;
            }
            nestLevel++;
        }
    }

    return err;
}

} // namespace ASN1
} // namespace chip