/*
 * UltraStar Deluxe - Karaoke Game
 *
 * UltraStar Deluxe is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 this program; see the file COPYING. If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#include <cstddef>

#include <GL/gl.h>

#include "static.hpp"

namespace usdx
{
	Static::Static(const RgbColor& stroke)
		: stroke(stroke), fill(0,0,0,0), filled(false), stroked(true),
		  stroke_width(1.0f), vertices(NULL), vertices_count(0)
	{
	}

	Static::Static(const Static& copy)
		: stroke(copy.stroke), fill(copy.fill), filled(copy.filled),
		  stroked(copy.stroked), stroke_width(1.0f), vertices(NULL),
		  vertices_count(0)
	{
		if (copy.vertices != NULL) {
			vertices_count = copy.vertices_count;
			vertices = new float[copy.vertices_count * 2];
			for (size_t i = 0; i < (copy.vertices_count * 2); i++) {
				vertices[i] = copy.vertices[i];
			}
		}
	}

	Static::~Static()
	{
		if (vertices != NULL) {
			delete[] vertices;
			vertices = NULL;
		}
	}

	Static& Static::operator=(const Static& copy)
	{
		if (this != &copy) {
			stroke = copy.stroke;
			fill = copy.fill;
			filled = copy.filled;
			stroked = copy.stroked;
			stroke_width = copy.stroke_width;
			vertices_count = 0;

			if (vertices != NULL) {
				delete[] vertices;
				vertices = NULL;
			}

			if (copy.vertices != NULL) {
				vertices_count = copy.vertices_count;
				vertices = new float[copy.vertices_count * 2];
				for (size_t i = 0; i < (copy.vertices_count * 2); i++) {
					vertices[i] = copy.vertices[i];
				}
			}
		}

		return *this;
	}

	void Static::draw(void)
	{
		// shortcut if not initilized or nothing to draw
		if ((vertices == NULL) || !(filled || stroked))
			return;

		glEnableClientState(GL_VERTEX_ARRAY);
		glEnableClientState(GL_COLOR_ARRAY);

		glVertexPointer(2, GL_FLOAT, 0, vertices);

		if (filled) {
			// draw filling
			glEnable(GL_BLEND);
			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

			glColorPointer(fill.get_array_comonent_count(), GL_UNSIGNED_BYTE,
						   0, fill.get_array(vertices_count));
			this->draw_fill();
			glDisable(GL_BLEND);
		}

		if (stroked) {
			// draw border
			glColorPointer(stroke.get_array_comonent_count(), GL_UNSIGNED_BYTE,
						   0, stroke.get_array(vertices_count));
			glLineWidth(stroke_width);
			this->draw_stroke();
		}

		glDisableClientState(GL_VERTEX_ARRAY);
		glDisableClientState(GL_COLOR_ARRAY);
	}

	void Static::register_vertices(const float *vertices, const size_t count)
	{
		if (this->vertices != NULL) {
			delete[] this->vertices;
			this->vertices = NULL;
		}

		this->vertices_count = count;
		this->vertices = new float[this->vertices_count * 2];
		for (size_t i = 0; i < (this->vertices_count * 2); i++) {
			this->vertices[i] = vertices[i];
		}
	}

	size_t Static::get_vertices_count(void) const
	{
		return vertices_count;
	}

	void Static::set_stroke(const RgbColor& stroke)
	{
		this->stroke = stroke;
	}

	RgbColor Static::get_stroke(void) const
	{
		return stroke;
	}

	void Static::set_fill(const RgbaColor& fill)
	{
		this->fill = fill;
	}

	RgbaColor Static::get_fill(void) const
	{
		return fill;
	}

	void Static::set_filled(const bool filled)
	{
		this->filled = filled;
	}

	bool Static::is_filled(void) const
	{
		return filled;
	}

	void Static::set_stroked(const bool stroked)
	{
		this->stroked = stroked;
	}

	bool Static::is_stroked(void) const
	{
		return stroked;
	}

	void Static::set_stroke_width(const float stroke_width)
	{
		this->stroke_width = stroke_width;
	}

	float Static::get_stroke_width(void) const
	{
		return stroke_width;
	}
}