//
//  Canvas.hpp
//  AwesomeAttractorND
//
//  Created by Joshua Moerman on 10/28/11.
//  Copyright 2011 Vadovas. All rights reserved.
//

/*
 Interface (or Concept) Canvas:
	Canvas canvas(width, height, ...);		Constructs a Canvas with given dimensions
	canvas[x][y]...[z]						Returns a (const) reference to an element
	canvas.plot(position)					Plots on the canvas (where position is normalized, ie in the unit-cube)
	canvas.size<N>()						gives width/size for the given dimension N.
	canvas.begin() .end()					gives iterators to the elements (directly)
 */

#ifndef AwesomeAttractorND_Canvas_hpp
#define AwesomeAttractorND_Canvas_hpp

#include <vector>
#include <iterator>
#include <array>
#include <numeric>

template <typename T>
class Canvas2D {
	typedef T value_type;
	typedef std::vector<value_type> Row;
	typedef std::vector<Row> Storage;

public:
	static constexpr size_t dimension = 2;
	static constexpr bool layered = false;
	
	Canvas2D(size_t width, size_t height)
	: storage(height, Row(width, 0))
	{}
	
	Row & operator[](size_t r){
		return storage[r];
	}
	
	Row const & operator[](size_t r) const {
		return storage[r];
	}
	
	void plot(double const * const position){
		const size_t width = size<0>();
		const size_t height = size<1>();
		
		const int c = 0.5*position[0]*width + width*.5;
		const int r = 0.5*position[1]*width + height*.5;
		
		if(0 <= c && (size_t)c < width && 0 <= r && (size_t)r < height)
			storage[r][c]++;
	}
	
	size_t size() const {
		return size<0>() * size<1>();
	}
	
	template <size_t N>
	size_t size() const {
		if ( N == 0 ) return storage.front().size();
		if ( N == 1 ) return storage.size();
		return 0;
	}
	
	struct iterator;
	iterator begin(){
		return iterator(this);
	}
	iterator end(){
		return iterator(this, 0, size<1>());
	};
	
	struct const_iterator;
	const_iterator begin() const {
		return const_iterator(this);
	}
	
	const_iterator end() const {
		return const_iterator(this, 0, size<1>());
	}
	
	const_iterator cbegin() const {
		return const_iterator(this);
	}
	
	const_iterator cend() const {
		return const_iterator(this, 0, size<1>());
	}
	
	struct iterator : public std::iterator<std::forward_iterator_tag, value_type> {
		iterator(iterator const & rh)
		: canvas(rh.canvas)
		, c(rh.c)
		, r(rh.r)
		{}
		
		iterator & operator++(){
			++c;
			if (c >= canvas->size<0>()) {
				c = 0;
				++r;
			}
			return *this;
		}
		
		iterator operator++(int){
			iterator temp(*this);
			++(*this);
			return temp;
		}
		
		bool operator==(iterator const & rh) const {
			return canvas == rh.canvas && c == rh.c && r == rh.r;
		}
		
		bool operator!=(iterator const & rh) const {
			return canvas != rh.canvas || c != rh.c || r != rh.r;
		}
		
		value_type & operator*(){
			return (*canvas)[r][c];
		}
		
		value_type const & operator*() const {
			return (*canvas)[r][c];
		}
		
		value_type & operator->(){
			return (*canvas)[r][c];
		}
		
		value_type const & operator->() const {
			return (*canvas)[r][c];
		}
		
	private:
		friend class Canvas2D;
		iterator(Canvas2D * canvas, size_t c = 0, size_t r = 0)
		: canvas(canvas)
		, c(c)
		, r(r)
		{}
		
		iterator();
		
		Canvas2D * canvas;
		size_t c;
		size_t r;
	};
	
	struct const_iterator : public std::iterator<std::forward_iterator_tag, value_type const> {
		const_iterator(const_iterator const & rh)
		: canvas(rh.canvas)
		, c(rh.c)
		, r(rh.r)
		{}
		
		const_iterator & operator++(){
			++c;
			if (c >= canvas->size<0>()) {
				c = 0;
				++r;
			}
			return *this;
		}
		
		const_iterator operator++(int){
			const_iterator temp(*this);
			++(*this);
			return temp;
		}
		
		bool operator==(const_iterator const & rh) const {
			return canvas == rh.canvas && c == rh.c && r == rh.r;
		}
		
		bool operator!=(const_iterator const & rh) const {
			return canvas != rh.canvas || c != rh.c || r != rh.r;
		}
		
		value_type const & operator*() const {
			return (*canvas)[r][c];
		}
		
		value_type const & operator->() const {
			return (*canvas)[r][c];
		}
		
	private:
		friend class Canvas2D;
		const_iterator(Canvas2D const * canvas, size_t c = 0, size_t r = 0)
		: canvas(canvas)
		, c(c)
		, r(r)
		{}
		
		const_iterator();
		
		Canvas2D const * canvas;
		size_t c;
		size_t r;
	};
	
private:
	Storage storage;
};

template <typename Canvas>
class LayeredCanvas {
public:
	static constexpr size_t dimension = Canvas::dimension;
	static constexpr bool layered = true;
	
	LayeredCanvas(size_t width, size_t height, size_t layers)
	: canvae(layers, Canvas(width, height))
	{}
	
	Canvas & operator[](size_t layer){
		return canvae[layer];
	}
	
	Canvas const & operator[](size_t layer) const {
		return canvae[layer];
	}
	
	size_t layers() const {
		return canvae.size();
	}
	
	size_t size() const {
		return canvae.front().size();
	}
	
	template <size_t N>
	size_t size() const {
		return canvae.front().size<N>();
	}
	
	void plot(double const * position, size_t layer){
		canvae[layer].plot(position);
	}

private:
	std::vector<Canvas> canvae;
};

template <typename C>
typename std::enable_if<!C::layered, bool>::type filled(C const & canvas, double threshold) {
	struct functor {
		size_t operator()(size_t x, size_t y){
			if(y > 0) return ++x;
			else return x;
		}
	} f;
	size_t nonempty_pixels = std::accumulate(canvas.begin(), canvas.end(), 0ul, f);
	return nonempty_pixels > threshold * canvas.size();
}

template <typename C>
typename std::enable_if<C::layered, bool>::type filled(C const & canvas, double threshold) {
	for (unsigned int l = 0; l < canvas.layers(); ++l) {
		if (!filled(canvas[l], threshold)) {
			return false;
		}
	}
	return true;
}

#endif