//
// Copyright 2020 Peter Dimov
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/boostorg/json
//

//[example_cbor

/*
    This example implements simple parsing and serialization of a
    subset of CBOR types that are directly supported by JSON.
*/

#include <boost/json.hpp>
#include <boost/endian.hpp>
#include <stdexcept>
#include <fstream>
#include <iostream>

using namespace boost::json;

void serialize_cbor_number(
    unsigned char mt, std::uint64_t n, std::vector<unsigned char> & out )
{
    mt <<= 5;

    if( n < 24 )
    {
        out.push_back( static_cast<unsigned char>( mt + n ) );
    }
    else if( n < 256 )
    {
        unsigned char data[] = { static_cast<unsigned char>( mt + 24 ), static_cast<unsigned char>( n ) };
        out.insert( out.end(), std::begin( data ), std::end( data ) );
    }
    else if( n < 65536 )
    {
        unsigned char data[] = { static_cast<unsigned char>( mt + 25 ), static_cast<unsigned char>( n >> 8 ), static_cast<unsigned char>( n ) };
        out.insert( out.end(), std::begin( data ), std::end( data ) );
    }
    else if( n < 0x1000000ull )
    {
        unsigned char data[ 5 ];

        data[ 0 ] = static_cast<unsigned char>( mt + 26 );
        boost::endian::endian_store<std::uint32_t, 4, boost::endian::order::big>( data + 1, static_cast<std::uint32_t>( n ) );

        out.insert( out.end(), std::begin( data ), std::end( data ) );
    }
    else
    {
        unsigned char data[ 9 ];

        data[ 0 ] = static_cast<unsigned char>( mt + 27 );
        boost::endian::endian_store<std::uint64_t, 8, boost::endian::order::big>( data + 1, n );

        out.insert( out.end(), std::begin( data ), std::end( data ) );
    }
}

void
serialize_cbor_string( string_view sv, std::vector<unsigned char>& out )
{
    std::size_t n = sv.size();
    serialize_cbor_number( 3, n, out );

    out.insert( out.end(), sv.data(), sv.data() + n );
}

void
serialize_cbor_value( const value& jv, std::vector<unsigned char>& out )
{
    switch( jv.kind() )
    {
    case kind::null:
        out.push_back( 224 + 22 );
        break;

    case kind::bool_:
        out.push_back( 224 + 20 + jv.get_bool() );
        break;

    case kind::int64:
        {
            std::int64_t n = jv.get_int64();
            if( n >= 0 )
                serialize_cbor_number( 0, n, out );
            else
                serialize_cbor_number( 1, ~n, out );
        }
        break;

    case kind::uint64:
        serialize_cbor_number( 0, jv.get_uint64(), out );
        break;

    case kind::double_:
        {
            unsigned char data[ 9 ];
            data[ 0 ] = 224 + 27;
            boost::endian::endian_store<double, 8, boost::endian::order::big>( data + 1, jv.get_double() );

            out.insert( out.end(), std::begin(data), std::end(data) );
        }
        break;

    case kind::string:
        serialize_cbor_string( jv.get_string(), out );
        break;

    case kind::array:
        {
            const array& ja = jv.get_array();
            std::size_t n = ja.size();

            out.reserve( out.size() + n + 1 );

            serialize_cbor_number( 4, n, out );

            for( std::size_t i = 0; i < n; ++i )
                serialize_cbor_value( ja[i], out );
        }
        break;

    case kind::object:
        {
            const object& jo = jv.get_object();
            std::size_t n = jo.size();

            out.reserve( out.size() + 3 * n + 1 );

            serialize_cbor_number( 5, n, out );

            for( const key_value_pair& kv: jo )
            {
                serialize_cbor_string( kv.key(), out );
                serialize_cbor_value( kv.value(), out );
            }
        }
        break;
    }
}

BOOST_NORETURN
void
throw_eof_error()
{
    throw std::runtime_error( "Unexpected end of input" );
}

BOOST_NORETURN
void
throw_format_error( char const * err )
{
    throw std::runtime_error( err );
}

void
ensure( std::size_t n, const unsigned char* first, const unsigned char* last )
{
    if( static_cast<std::size_t>(last - first) < n )
        throw_eof_error();
}

const unsigned char*
parse_cbor_value(
    const unsigned char* first, const unsigned char* last, value& v );

const unsigned char*
parse_cbor_number(
    const unsigned char* first, const unsigned char* last, unsigned char ch, std::uint64_t& n )
{
    unsigned char cv = ch & 31;

    if( cv < 24 )
    {
        n = cv;
    }
    else if( cv == 24 )
    {
        ensure( 1, first, last );
        n = *first++;
    }
    else if( cv == 25 )
    {
        ensure( 2, first, last );
        n = boost::endian::load_big_u16( first );
        first += 2;
    }
    else if( cv == 26 )
    {
        ensure( 4, first, last );
        n = boost::endian::load_big_u32( first );
        first += 4;
    }
    else if( cv == 27 )
    {
        ensure( 8, first, last );
        n = boost::endian::load_big_u64( first );
        first += 8;
    }
    else if( cv == 31 )
    {
        // infinite array/object
        throw_format_error( "Infinite sequences aren't supported" );
    }
    else
    {
        throw_format_error( "Invalid minor type" );
    }

    return first;
}

const unsigned char*
parse_cbor_string(
    const unsigned char* first, const unsigned char* last, unsigned char ch, value& v )
{
    std::uint64_t n;
    first = parse_cbor_number( first, last, ch, n );

    ensure( n, first, last );

    string_view sv( reinterpret_cast<char const*>( first ), n );
    first += n;

    v = sv;
    return first;
}

const unsigned char*
parse_cbor_array(
    const unsigned char* first, const unsigned char* last, unsigned char ch, value& v )
{
    std::uint64_t n;
    first = parse_cbor_number( first, last, ch, n );

    array & a = v.emplace_array();

    a.resize( n );

    std::size_t i = 0;

    for( ; i < n; ++i ) // double[] fast path
    {
        ensure( 1, first, last );
        unsigned char ch2 = *first;

        if( ch2 != 0xFB ) break;

        ++first;
        ensure( 8, first, last );

        double w = boost::endian::endian_load<double, 8, boost::endian::order::big>( first );
        first += 8;

        a[ i ] = w;
    }

    for( ; i < n; ++i ) // int[] fast path
    {
        ensure( 1, first, last );
        unsigned char ch2 = *first;

        if( ch2 >= 0x40 ) break;

        ++first;

        std::uint64_t m;
        first = parse_cbor_number( first, last, ch2, m );

        if( ch2 < 0x20 )
        {
            a[ i ] = m;
        }
        else
        {
            a[ i ] = static_cast<std::int64_t>( ~m );
        }
    }

    for( ; i < n; ++i )
        first = parse_cbor_value( first, last, a[ i ] );

    return first;
}

const unsigned char*
parse_cbor_object(
    const unsigned char* first, const unsigned char* last, unsigned char ch, value& v )
{
    std::uint64_t n;
    first = parse_cbor_number( first, last, ch, n );

    object & o = v.emplace_object();

    o.reserve( n );

    for( std::size_t i = 0; i < n; ++i )
    {
        // key string

        ensure( 1, first, last );
        unsigned char ch2 = *first++;

        if( ( ch2 >> 5 ) != 3 )
            throw_format_error( "Object keys must be strings" );

        std::uint64_t m;
        first = parse_cbor_number( first, last, ch2, m );

        ensure( m, first, last );

        string_view sv( reinterpret_cast<char const*>( first ), m );
        first += m;

        // value

        first = parse_cbor_value( first, last, o[ sv ] );
    }

    return first;
}

const unsigned char*
parse_cbor_unsigned(
    const unsigned char* first, const unsigned char* last, unsigned char ch, value& v )
{
    std::uint64_t n;
    first = parse_cbor_number( first, last, ch, n );

    v = n;
    return first;
}

const unsigned char*
parse_cbor_signed(
    const unsigned char* first, const unsigned char* last, unsigned char ch, value& v )
{
    std::uint64_t n;
    first = parse_cbor_number( first, last, ch, n );

    v = static_cast<std::int64_t>( ~n );
    return first;
}

const unsigned char*
parse_cbor_semantic_tag(
    const unsigned char* first, const unsigned char* last, unsigned char ch, value& v )
{
    std::uint64_t n;
    first = parse_cbor_number( first, last, ch, n );

    // ignore semantic tags

    return parse_cbor_value( first, last, v );
}

const unsigned char*
parse_cbor_type7(
    const unsigned char* first, const unsigned char* last, unsigned char ch, value& v )
{
    switch( ch & 31 )
    {
    case 20:
        v = false;
        return first;

    case 21:
        v = true;
        return first;

    case 22:
        v = nullptr;
        return first;

    case 26: // float
    {
        ensure( 4, first, last );

        float w = boost::endian::endian_load<float, 4, boost::endian::order::big>( first );
        first += 4;

        v = w;
        return first;
    }

    case 27: // double
    {
        ensure( 8, first, last );

        double w = boost::endian::endian_load<double, 8, boost::endian::order::big>( first );
        first += 8;

        v = w;
        return first;
    }

    default:
        throw_format_error( "Invalid minor type for major type 7" );
    }
}

const unsigned char*
parse_cbor_value( const unsigned char* first, const unsigned char* last, value& v )
{
    ensure( 1, first, last );
    const unsigned char ch = *first++;

    switch( ch >> 5 )
    {
    case 0:
        return parse_cbor_unsigned( first, last, ch, v );

    case 1:
        return parse_cbor_signed( first, last, ch, v );

    case 2:
        throw_format_error( "Binary strings aren't supported" );

    case 3:
        return parse_cbor_string( first, last, ch, v );

    case 4:
        return parse_cbor_array( first, last, ch, v );

    case 5:
        return parse_cbor_object( first, last, ch, v );

    case 6:
        return parse_cbor_semantic_tag( first, last, ch, v );

    case 7:
        return parse_cbor_type7( first, last, ch, v );

    default:
        BOOST_JSON_UNREACHABLE();
    }
}

int
main(int argc, const char** argv)
{
    if( argc != 2 )
    {
        std::cerr << "Usage: cbor FILE_NAME\n";
        return EXIT_FAILURE;
    }

    std::ifstream is(argv[1]);
    is.exceptions(std::ios::badbit);

    const value jv = parse(is);

    std::vector<unsigned char> out;
    serialize_cbor_value( jv, out );

    value jv2;
    parse_cbor_value( out.data(), out.data() + out.size(), jv2 );

    if( jv != jv2 )
    {
        std::cerr << "Roundtrip check failed\n";
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}

//]