/*
 * Copyright (C) 2017 Charybdis Development Team
 * Copyright (C) 2017 Jason Volk <jason@zemos.net>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice is present in all copies.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once
#define HAVE_IRCD_JSON_INDEX_H

struct ircd::json::index
{
	struct const_iterator;

	using key_type = value;
	using mapped_type = value;
	using value_type = const member;
	using size_type = size_t;
	using difference_type = size_t;
	using key_compare = std::less<member>;
	using index_type = std::vector<member>;

	index_type idx;

	const_iterator begin() const;
	const_iterator end() const;
	const_iterator cbegin();
	const_iterator cend();

	bool empty() const;
	size_t count() const;
	size_t serialized() const;

	const_iterator find(const string_view &name) const;
	bool has(const string_view &name) const;

	const value &operator[](const string_view &name) const;
	const value &at(const string_view &name) const;

	const_iterator erase(const const_iterator &s, const const_iterator &e);
	void erase(const const_iterator &s);
	bool erase(const string_view &name);

	operator std::string() const;

	IRCD_OVERLOAD(recursive)

	index(std::initializer_list<member>);
	index(const object &d);
	index(recursive_t, const object &d);
	index() = default;
	index(index &&) = default;
	index(const index &) = delete;

	friend index &operator+=(index &, const object &);      // integration
	friend index operator+(const object &, const object &);  // integral

	friend size_t serialized(const index &);
	friend string_view stringify(mutable_buffer &, const index &);
	friend std::ostream &operator<<(std::ostream &, const index &);
};

struct ircd::json::index::const_iterator
{
	using value_type = const member;
	using pointer = value_type *;
	using reference = value_type &;
	using difference_type = size_t;
	using iterator_category = std::bidirectional_iterator_tag;

  protected:
	friend class index;

	index::index_type::const_iterator it;

	operator const auto &() const                   { return it;                                   }

	const_iterator(const decltype(it) &it)
	:it{it}
	{}

  public:
	value_type *operator->() const                  { return it.operator->();                      }
	value_type &operator*() const                   { return it.operator*();                       }

	const_iterator &operator++()                    { ++it; return *this;                          }
	const_iterator &operator--()                    { --it; return *this;                          }

	friend bool operator==(const const_iterator &a, const const_iterator &b);
	friend bool operator!=(const const_iterator &a, const const_iterator &b);
	friend bool operator<(const const_iterator &a, const const_iterator &b);
};

inline const ircd::json::value &
ircd::json::index::operator[](const string_view &name)
const
{
	return at(name);
}

inline bool
ircd::json::index::has(const string_view &name)
const
{
	return find(name) != end();
}

inline ircd::json::index::const_iterator
ircd::json::index::find(const string_view &name)
const
{
	return std::find(std::begin(idx), std::end(idx), name);
}

inline size_t
ircd::json::index::count()
const
{
	return idx.size();
}

inline bool
ircd::json::index::empty()
const
{
	return idx.empty();
}

inline ircd::json::index::const_iterator
ircd::json::index::cbegin()
{
	return { std::begin(idx) };
}

inline ircd::json::index::const_iterator
ircd::json::index::cend()
{
	return { std::end(idx) };
}

inline ircd::json::index::const_iterator
ircd::json::index::begin()
const
{
	return { std::begin(idx) };
}

inline ircd::json::index::const_iterator
ircd::json::index::end()
const
{
	return { std::end(idx) };
}

inline bool
ircd::json::operator<(const index::const_iterator &a, const index::const_iterator &b)
{
	return a.it < b.it;
}

inline bool
ircd::json::operator!=(const index::const_iterator &a, const index::const_iterator &b)
{
	return a.it != b.it;
}

inline bool
ircd::json::operator==(const index::const_iterator &a, const index::const_iterator &b)
{
	return a.it == b.it;
}