/* Copyright 2015, Michele Santullo
 * This file is part of DoorKeeper.
 *
 * DoorKeeper is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * DoorKeeper is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with DoorKeeper.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace dk {
	template <uint32_t D>
	struct LayeredViewport<D>::ViewportItem {
		ViewportItem ( const TileInfo<D>& parTInfo, Tyler<D>& parTyler );
		ViewportItem ( ViewportItem&& ) = default;
		ViewportItem ( const ViewportItem& ) = delete;

		TileInfo<D> tile_info;
		Viewport<D> viewport;
		int ref_count;

		bool operator== ( const TileInfo<D>& parOther ) const a_pure;
		ViewportItem& operator= ( const ViewportItem& ) = default;
		ViewportItem& operator= ( ViewportItem&& );
	};

	template <uint32_t D>
	LayeredViewport<D>::ViewportItem::ViewportItem (const TileInfo<D>& parTInfo, Tyler<D>& parTyler) :
		tile_info(parTInfo),
		viewport(parTyler, &tile_info),
		ref_count(1)
	{
	}

	template <uint32_t D>
	bool LayeredViewport<D>::ViewportItem::operator== (const TileInfo<D>& parOther) const {
		return tile_info == parOther;
	}

	template <uint32_t D>
	typename LayeredViewport<D>::ViewportItem& LayeredViewport<D>::ViewportItem::operator= (ViewportItem&& parOther) {
		tile_info = std::move(parOther.tile_info);
		viewport = std::move(parOther.viewport);
		ref_count = parOther.ref_count;
		return *this;
	}

	template <uint32_t D>
	LayeredViewport<D>::LayeredViewport (LayeredViewport<D>&& parOther) :
		m_views(std::move(parOther.m_views)),
		m_tyler(parOther.m_tyler),
		m_tyler_id(std::move(m_tyler_id))
	{
	}

	template <uint32_t D>
	LayeredViewport<D>::LayeredViewport (Tyler<D>& parTyler) :
		m_tyler(&parTyler)
	{
		DK_ASSERT(m_tyler);
		for (const auto& layer : *m_tyler) {
			this->on_layer(layer, true);
		}

		using std::placeholders::_1;
		using std::placeholders::_2;
		m_tyler_id = m_tyler->register_for_layeradd(std::bind(&LayeredViewport<D>::on_layer, this, _1, _2));
	}

	template <uint32_t D>
	LayeredViewport<D>::~LayeredViewport() noexcept {
		m_tyler->unregister_for_layeradd(m_tyler_id);
	}

	template <uint32_t D>
	LayeredViewport<D>& LayeredViewport<D>::operator+= (const coords_f& parValue) {
		for (auto& view : m_views) {
			view.viewport += parValue;
		}
		return *this;
	}

	template <uint32_t D>
	LayeredViewport<D>& LayeredViewport<D>::operator-= (const coords_f& parValue) {
		for (auto& view : m_views) {
			view.viewport -= parValue;
		}
		return *this;
	}

	template <uint32_t D>
	void LayeredViewport<D>::on_layer (const LayerBase<D>& parLayer, bool parAdded) {
		const TileInfo<D> tinfo(parLayer);
		auto it_found = std::find(m_views.begin(), m_views.end(), tinfo);

		if (parAdded) {
			if (m_views.end() == it_found) {
				m_views.emplace_back(ViewportItem(tinfo, *m_tyler));
			}
			else {
				++it_found->ref_count;
			}
		}
		else {
			DK_ASSERT(m_views.end() != it_found);
			--it_found->ref_count;
			if (0 == it_found->ref_count) {
				m_views.erase(it_found);
			}
		}
	}

	template <uint32_t D>
	auto LayeredViewport<D>::begin() -> iterator {
		IterableViewport<D> (LayeredViewport<D>::*vpfunc)(const LayerBase<D>&) = &LayeredViewport<D>::viewport;
		boost::function<IterableViewport<D>(const LayerBase<D>&)> functor = boost::bind(vpfunc, this, _1);
        auto it_beg = m_tyler->begin();
		return boost::make_transform_iterator(it_beg, functor);
	}

	template <uint32_t D>
	auto LayeredViewport<D>::begin() const -> const_iterator {
		const IterableViewport<D> (LayeredViewport<D>::*vpfunc)(const LayerBase<D>&) const = &LayeredViewport<D>::viewport;
		return const_iterator(m_tyler->begin(), boost::bind(&vpfunc, this, _1));
	}

	template <uint32_t D>
	auto LayeredViewport<D>::end() -> iterator {
		IterableViewport<D> (LayeredViewport<D>::*vpfunc)(const LayerBase<D>&) = &LayeredViewport<D>::viewport;
		boost::function<IterableViewport<D>(const LayerBase<D>&)> functor = boost::bind(vpfunc, this, _1);
		return boost::make_transform_iterator(m_tyler->end(), functor);
	}

	template <uint32_t D>
	auto LayeredViewport<D>::end() const -> const_iterator {
		const IterableViewport<D> (LayeredViewport<D>::*vpfunc)(const LayerBase<D>&) const = &LayeredViewport<D>::viewport;
		return const_iterator(m_tyler->end(), boost::bind(&vpfunc, this, _1));
	}

	template <uint32_t D>
	IterableViewport<D> LayeredViewport<D>::viewport (const LayerBase<D>& parLayer) {
		return const_cast<const LayeredViewport<D>*>(this)->viewport(parLayer);
	}

	template <uint32_t D>
	const IterableViewport<D> LayeredViewport<D>::viewport (const LayerBase<D>& parLayer) const {
		const TileInfo<D> tinfo(parLayer);
		auto it_found = std::find(m_views.begin(), m_views.end(), tinfo);
		DK_ASSERT(m_views.end() != it_found);
		return IterableViewport<D>(&it_found->viewport, &parLayer);
	}
} //namespace dk