#pragma once
#include "Vector3D.h"
#include "Vertex.h"
#include "Polygon3D.h"
#include "Matrix.h"
#include "Camera.h"
#include <vector>
#include <algorithm>

using namespace std;

class Model
{
public:
	Model();
	~Model();

	vector<Polygon3D>& GetPolygons(void);
	vector<Vertex>& GetVertices(void);
	const vector<Matrix>& GetPendingTransforms(void);

	size_t GetPolygonCount(void);
	size_t GetVerticesCount(void);
	size_t GetPendingTransformCount(void);

	void AddVertex(float x, float y, float z);
	void AddPolygon(int index0, int index1, int index2);
	void EnqueueTransform(Matrix transform);
	void ClearPendingTransforms();

	const Polygon3D& GetPolygon(int index) const;
	const Vertex& GetVertex(int polygonIndex, int vertexPolygonIndex) const;
	const Vertex& GetVertex(int index) const;	

	vector<Vertex> GetPolygonVertexArray(int index) const;
	void SetPolygonColor(int index, COLORREF color);
	void SetVertexColor(int polyIndex, int vertIndex, COLORREF color);

	void SetReflectionCoefficient(float red, float green, float blue);
	void SetReflectionCoefficient(ColRef color, float value);
	void SetRedReflectionCoefficient(float value);
	void SetGreenReflectionCoefficient(float value);
	void SetBlueReflectionCoefficient(float value);

	float GetReflectionCoefficient(ColRef color) const;
	float GetRedReflectionCoefficient() const;
	float GetGreenReflectionCoefficient() const;
	float GetBlueReflectionCoefficient() const;

	void ApplyTransformToLocalVertices(const Matrix& transform);
	void ApplyTransformToTransformedVertices(const Matrix& transform);
	void DehomogenizeAllVertices(void);

	void CalculateBackfaces(Camera& currentCamera);
	void CalculateVertexNormals();
	void Sort(void);

private:
	vector<Polygon3D> _polygons;
	vector<Vertex> _vertices;
	vector<Vertex> _transformedVertices;
	vector<Matrix> _pendingTransforms;
	
	float _kdRed;
	float _kdGreen;
	float _kdBlue;
};