#pragma once

/******************************************************************************
*
*   Copyright (c) 2019 AT&T Intellectual Property.
*   Copyright (c) 2018-2019 Nokia.
*
*   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.
*
******************************************************************************/

// Standard Includes: ANSI C/C++, MSA, and Third-Party Libraries
#include <boost/intrusive/list.hpp>
#include <cstring>

// Local Includes: Application specific classes, functions, and libraries
#include "asn/constraints.hpp"
#include "asn/identifier.hpp"

namespace asn {

enum class element_type : uint8_t
{
	 T_BOOLEAN
	,T_INTEGER
	,T_ENUMERATED
	,T_REAL
	,T_BITSTRING
	,T_OCTETSTRING
	,T_NULL
	,T_SEQUENCE
	,T_SEQUENCE_OF
	,T_SET
	,T_SET_OF
	,T_CHOICE
	,T_OBJECTIDENTIFIER
	,T_OBJFIELD_FTV
	,T_OBJFIELD_TF
};

/***************************************************************************************
* BASE
***************************************************************************************/

struct base
{
	static constexpr bool optional = false;
	static constexpr bool extension = false;

	static constexpr char const* name() {return "";}

	void setpresent(bool p) {is_set = p;}
	void clear() {is_set = false;}

	bool is_valid() const {return is_set;}

protected:
	base() {}
	void set() {is_set = true;}
protected:
	bool is_set {false};

	base& operator=(const base&) = delete;
	base (const base&) = delete;
};

/***************************************************************************************
* IE_NULL
***************************************************************************************/

struct nulltype : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::NULL_TYPE), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_NULL;
	static constexpr const char* name() {return "NULL";}

	void clear() {}
};

/***************************************************************************************
* T_BOOLEAN
***************************************************************************************/

struct boolean : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::BOOLEAN), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_BOOLEAN;
	static constexpr const char* name() {return "BOOLEAN";}

	using value_type = bool;

	void set(value_type vl) { m_value = vl; base::set();}
	value_type get() const { return m_value; }
	void clear() { m_value = false; base::clear();}

private:
	value_type  m_value {false};
};

/***************************************************************************************
* T_INTEGER
***************************************************************************************/
template < class Constraint = constraints<false> >
struct integer : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::INTEGER), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_INTEGER;
	static constexpr const char* name() {return "INTEGER";}

	using constraint_t	= Constraint;
	using value_type 	= int64_t;

	bool equal(value_type v) const {return m_value == v;}

	void set(value_type v) { m_value = v; base::set();}
	value_type get() const { return m_value; }

	void clear() { m_value = 0; base::clear();}

private:
	value_type m_value;
};

/***************************************************************************************
* T_ENUMERATED
***************************************************************************************/
template<int TotalNumEntries, int NumExtEntries, bool Extended>
struct enumerated : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::ENUMERATED), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_ENUMERATED;
	static constexpr const char* name() {return "ENUMERATED";}

	using constraint_t	= seq_range<TotalNumEntries, NumExtEntries, Extended>;
	using value_type	= typename constraint_t::value_type;

	bool equal(value_type v) const {return m_value == v;}
	void set(value_type vl) { m_value = vl; base::set();}
	value_type get() const { return m_value; }
	void clear() { m_value = constraint_t::default_value; base::clear();}

private:
	value_type m_value;
};

/***************************************************************************************
* T_OCTETSTRING
***************************************************************************************/
template< class Constraint = constraints<false> >
struct ostring : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::OCTET_STRING), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_OCTETSTRING;
	static constexpr const char* name() {return "OCTET STING";}
	using constraint_t	= Constraint;

	struct value_type
	{
		value_type() {}
		value_type(size_t size, const char* data) : m_size(size), m_data(reinterpret_cast<const uint8_t*>(data)) {}

		size_t size() const                 { return m_size; }
		const uint8_t* data() const         { return m_data; }

		using const_iterator = uint8_t const*;
		const_iterator begin() const        { return data(); }
		const_iterator end() const          { return begin() + size(); }

		void assign(void const* p, size_t sz)  { m_data = static_cast<uint8_t const*>(p); m_size = sz; }

	private:
		const uint8_t*	m_data{ 0 };
		size_t			m_size{ 0 };
	};

	value_type const& get() const { return m_value; }

	//Use std::string, std::vector or IE_OSTR::value_type
	template<typename T> value_type const& set(T const& tval)
	{
		set(tval.size(), tval.data());
		base::set();
		return m_value;
	}

	void set(size_t size, void const* data)
	{
		m_value.assign(data, size);
		base::set();
	}

	template<class AT>
	ostring& emplace(AT& allocator, size_t size, uint8_t const * data_in)
	{
		if(size)
		{
			base::clear();
			uint8_t* data_out = allocator.alloc_bytes(size);
			if (data_out)
			{
				memcpy(data_out, data_in, size);
				set(size, data_out);
			}
		}
		else
			base::set();
		return *this;
	}

	template<class AT, class T>
	ostring& emplace(AT& allocator, T const& tval)
	{
		return emplace(allocator, tval.size(), reinterpret_cast<const uint8_t*>(tval.data()));
	}

	void clear() { m_value = value_type{}; base::clear();}

private:
	value_type m_value;
};

/***************************************************************************************
* T_BITSTRING
***************************************************************************************/
template<class Constraint = constraints<false> >
struct bstring : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::BIT_STRING), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_BITSTRING;
	static constexpr const char* name() {return "BIT STING";}
	using constraint_t	= Constraint;

	struct value_type
	{
		value_type() {}
		value_type(size_t size, const char* data, size_t bitqty) : m_size(size), m_data(reinterpret_cast<const uint8_t*>(data)), m_bitqty(bitqty){}

		size_t size() const { return m_size; }
		const uint8_t* data() const { return m_data; }
		size_t bitqty() const { return m_bitqty; }

		void assign(void const* p, size_t sz, size_t bits)  { m_data = static_cast<uint8_t const*>(p); m_size = sz; m_bitqty = bits; }

	private:
		const uint8_t*	m_data{ nullptr };
		size_t			m_size{ 0 };
		size_t			m_bitqty{ 0 };
	};

	value_type const& get_buffer() const { return m_value; }

	size_t get_bitqty()            const { return m_value.bitqty(); }

	//Use std::string, std::vector or IE_BSTR::value_type
	template<typename T> value_type const& set_buffer(T& tval, size_t bitqty)
	{
		m_value.assign(tval.data(), tval.size(), bitqty);
		base::set();
		return m_value;
	}

	void set_buffer(size_t bitqty, const uint8_t* data)
	{
		m_value.assign(data, (bitqty +7) >> 3, bitqty);
		base::set();
	}

	template<class AT>
	bstring& emplace_buffer(AT& allocator, size_t bitqty, uint8_t const * data_in)
	{
		size_t size = (bitqty +7) >> 3;
		uint8_t* data_out = allocator.alloc_bytes(size);
		if (!data_out) {
			throw std::bad_alloc();
		}
		memcpy(data_out, data_in, size);
		set_buffer(bitqty, data_out);
		return *this;
	}

	void clear() { m_value = value_type{}; base::clear();}

	uint64_t get_number() const
	{
		uint64_t retval{0};
		size_t i = 0;
		for(; i < m_value.size() - 1; ++i)
		{
			retval <<= 8;
			retval |= m_value.data()[i];
		}

		uint8_t shift = m_value.bitqty() % 8;
		if (shift)
		{
			retval <<= shift;
		}
		else
		{
			retval <<= 8;
		}

		retval |= m_value.data()[i];

		return retval;
	}

	template<class AT>
	void set_number(AT& allocator, size_t bitqty, uint64_t data)
	{
		size_t size = (bitqty +7) >> 3;
		uint8_t* data_out = allocator.alloc_bytes(size);
		if (!data_out) {
			throw std::bad_alloc();
		}

		const uint8_t shift = bitqty % 8;
		if (shift)
		{
			data_out[size-1] = data & (0xFF >> (8 - shift));
			data >>= shift;
		}
		else
		{
			data_out[size-1] = data & (0xFF);
			data >>= 8;
		}

		for (size_t i = 1; i <= size - 1; i++)
		{
			data_out[size-1-i] = data & (0xFF);
			data >>= 8;
		}

		m_value.assign(data_out, size, bitqty);
		base::set();
	}

private:
	value_type m_value;
};

/***************************************************************************************
* T_CHOICE
***************************************************************************************/
template<int TotalNumEntries, int NumExtEntries, bool Extended>
struct choice : base
{
  using asn_identifier_t = identifier<class_type_t::UNSPECIFIED, static_cast<tag_value_t>(tag_rvalue_t::CHOICE), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_CHOICE;
	static constexpr const char* name() {return "CHOICE";}

	using constraint_t	= seq_range<TotalNumEntries, NumExtEntries, Extended>;
	using index_type	= size_t;
	using value_type	= size_t;

	static constexpr index_type fst_index = 1;
	static constexpr index_type ext_index = fst_index + TotalNumEntries;

	static index_type normalize(index_type idx) 	{return idx - fst_index;}
	static index_type denormalize(index_type idx) 	{return idx + fst_index;}
};

/***************************************************************************************
* T_SEQUENCE
***************************************************************************************/
template<int TotalNumEntries, int NumExtEntries, bool Extended, int NumOptEntries = 0>
struct sequence : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::SEQUENCE), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_SEQUENCE;
	static constexpr const char* name() {return "SEQUENCE";}

	static constexpr bound_t num_total_entries 	= TotalNumEntries;
	static constexpr bound_t num_opt_entries 	= NumOptEntries;
	static constexpr bound_t num_ext_entries 	= NumExtEntries;

	using constraint_t	= seq_range<TotalNumEntries, NumExtEntries, Extended>;

};

/***************************************************************************************
* T_SEQUENCE_OF
***************************************************************************************/
template<typename T, class Constraint = constraints<false> >
struct sequenceof : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::SEQUENCE_OF), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_SEQUENCE_OF;
	static constexpr const char* name() {return "SEQUENCE OF";}

	struct value_type : T, boost::intrusive::list_base_hook< boost::intrusive::link_mode<boost::intrusive::auto_unlink> >
	{
		value_type(){}
	private:
		value_type& operator=(const value_type&) = delete;
		value_type (const value_type&) = delete;
	};

	using values_t 		= boost::intrusive::list<value_type, boost::intrusive::constant_time_size<false>>;
	using constraint_t	= Constraint;
	using element_t		= T;

	void clear()                        { m_list.clear(); base::clear();}
	size_t size() const                 { return m_list.size(); }
	template<class Predicate>
	void sort(Predicate const& p)       { m_list.sort(p); }

	template<class V>
	void set(V& v)                      {for(auto & e : v) {m_list.push_back(e);} base::set();}

	void push_back(value_type& v)       { m_list.push_back(v); base::set();}

	template<class AT> //Note: Allocator must return word alligned buffer!
	T& emplace_back(AT& allocator)
	{
		uint8_t* data = allocator.alloc_bytes(sizeof(value_type));
		if(!data)
			throw std::bad_alloc();
		value_type* v = new (data) value_type;
		push_back(*v);
		return *v;
	};

	using iterator = typename values_t::iterator;
	iterator begin()                    { return m_list.begin(); }
	iterator end()                      { return m_list.end(); }

	using const_iterator = typename values_t::const_iterator;
	const_iterator begin() const        { return m_list.begin(); }
	const_iterator end() const          { return m_list.end(); }

	sequenceof(){}

private:
	values_t m_list;
};

/***************************************************************************************
* T_OBJFIELD_FTV
***************************************************************************************/
template<typename T, bool>
struct fixedtypefield : T
{
	static constexpr element_type ie_type = element_type::T_OBJFIELD_FTV;

	T& ref_nested() {return *this;}
	T const & ref_nested() const {return *this;}
};

/***************************************************************************************
* T_OBJFIELD_TF
***************************************************************************************/
template<bool>
struct typefield : base
{
	static constexpr element_type ie_type = element_type::T_OBJFIELD_TF;
	static constexpr const char* name() {return "type-field";}

	typefield& ref_nested() {return *this;}
	typefield const& ref_nested() const {return *this;}

	bool is_unknown() const {return false;}
};

/***************************************************************************************
* T_OBJECTIDENTIFIER
***************************************************************************************/
struct oid : ostring<>
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::OBJECT_IDENTIFIER), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_OBJECTIDENTIFIER;
	static constexpr const char* name() {return "OBJECT IDENTIFIER";}
};

/***************************************************************************************
* T_PRINTABLESTRING
***************************************************************************************/
template<class Constraint = constraints<false> >
struct printable_string : ostring<Constraint>
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::PrintableString), tag_type_t::IMPLICIT>;
	static constexpr const char* name() {return "PrintableString";}
};

/***************************************************************************************
* T_IA5_STRING
***************************************************************************************/
template<class Constraint = constraints<false> >
struct ia5_string : ostring<Constraint>
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::IA5String), tag_type_t::IMPLICIT>;
	static constexpr const char* name() {return "IA5String";}
};

/***************************************************************************************
* T_GRAPHIC_STRING
***************************************************************************************/
template<class Constraint = asn::constraints<false> >
struct graphic_string : ostring<Constraint>
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::GraphicString), tag_type_t::IMPLICIT>;
	static constexpr const char* name() {return "IA5String";}
};

/***************************************************************************************
* T_UTF8_STRING
***************************************************************************************/
template<class Constraint = asn::constraints<false> >
struct utf8_string : ostring<Constraint>
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::UTF8String), tag_type_t::IMPLICIT>;
	static constexpr const char* name() {return "UTF8String";}
};

/***************************************************************************************
* T_SET
***************************************************************************************/
template<int TotalNumEntries, int NumExtEntries, bool Extended, int NumOptEntries = 0>
struct set : base
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::SET), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_SET;
	static constexpr const char* name() {return "SET";}

	static constexpr bound_t num_total_entries 	= TotalNumEntries;
	static constexpr bound_t num_opt_entries 	= NumOptEntries;
	static constexpr bound_t num_ext_entries 	= NumExtEntries;

	using constraint_t	= seq_range<TotalNumEntries, NumExtEntries, Extended>;
};

/***************************************************************************************
* T_SET_OF
***************************************************************************************/
template<typename T, class Constraint = constraints<false> >
struct setof : sequenceof<T, Constraint>
{
	using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::SET_OF), tag_type_t::IMPLICIT>;

	static constexpr element_type ie_type = element_type::T_SET_OF;
	static constexpr const char* name() {return "SET OF";}
};
} //namespace asn