#pragma once

#include "cscreen.h"

#define SET_OWNER_COLOR glColor3d( 0, 255, 0 )
#define SET_OPPO_COLOR glColor3d( 255, 0, 0 )

namespace Game
{
	float CScreen::fHypo;

	void CScreen::Set2DMode( )
	{
		glDisable( GL_DEPTH_TEST );
		glMatrixMode( GL_PROJECTION );
		glLoadIdentity( );
		gluOrtho2D( 0, ScreenWidth, ScreenHeigth, 0 );
		glMatrixMode( GL_MODELVIEW );
		glLoadIdentity( );
	}

	void CScreen::DrawPoint( int x, int y )
	{
		glVertex2d( x, y );
	}

	void CScreen::DrawLine( int x, int y, int x1, int x2 )
	{
		glPointSize( 1.0 );

		glVertex2d( x, y );

		glVertex2d( x1, x2 );
	}

	void CScreen::DrawMesh( )
	{
		Set2DMode( );
		glPushMatrix( );
		glColor3d( 0, 0, 0 );
		glBegin( GL_LINES );

		for( int i = CellSize; i < ScreenWidth; i += CellSize )
		{
			DrawLine( i, ScreenHeigth, i, -ScreenWidth );
		}

		for( int i = CellSize; i < ScreenHeigth; i += CellSize )
		{
			DrawLine( -ScreenHeigth, i, ScreenWidth, i );
		}

		glEnd( );
		glPopMatrix( );
	}
	
	void CScreen::DrawPlayersPoints( )
	{
		Set2DMode( );
		glPushMatrix( );
		glPointSize( ( float )CellSize * 0.4 );
		for( auto it = CGlobals::m_vPointInfo.begin( ); it < CGlobals::m_vPointInfo.end( ); it++ )
		{
			if( it->IsOppo( &CGlobals::m_LocalPlayer ) )
			{
				glColor3d( 255, 0, 0 );
			}
			else
			{
				glColor3d( 0, 255, 0 );
			}

			glBegin( GL_POINTS );

			cml::vector2i nearest = CScreen::GetNearestPoint( it->GetPoint( )->To2DVector( ) );

			CScreen::DrawPoint( nearest[ 0 ], nearest[ 1 ] );

			glEnd( );
		}

		glPopMatrix(  );
	}

	void CScreen::DrawAreas( )
	{
		Set2DMode( );
		glPushMatrix( );
		glPointSize( 1.0 );

		PointInfoList vecPoints;

		for( auto it = CGlobals::m_vPointInfo.begin( ); it < CGlobals::m_vPointInfo.end( ); it++ )
		{
			vecPoints.push_back( *it );

			CScreen::JoinNearestPoints( *it, vecPoints );
		}

		glPopMatrix( );
	}

	void CScreen::JoinNearestPoints( CPointInfo pointInfo, PointInfoList vecRealPoints )
	{
		cml::vector2i currentPoint = pointInfo.GetPoint()->To2DVector();

		for( auto it = vecRealPoints.begin( ); it < vecRealPoints.end( ); it++ )
		{
			Vector2DI nextPoint = it->GetPoint()->To2DVector( );

			if( currentPoint == nextPoint )
			{
				continue;
			}

			if( pointInfo.IsOppo( it->GetOwner( ) ) )
			{
				continue;
			}

			if( pointInfo.GetOwner( )->GetPlayerName( ) == CGlobals::m_LocalPlayer.GetPlayerName( ) )
			{
				SET_OWNER_COLOR;
			}
			else
			{
				SET_OPPO_COLOR;
			}

			glBegin( GL_LINES );

			float fDistance = Vector2DI( currentPoint - nextPoint ).length( );

			if( fDistance <= fHypo ) // PYTHAGORAAAAAAAAAAAAARTA
			{
				if( fDistance == fHypo )
				{
					Vector2dList vecPoints = CScreen::GetNearestOppoCoords( pointInfo, vecRealPoints );

					if( CScreen::GetNearestPointsCount( nextPoint, vecPoints ) == 2 )
					{
						continue;
					}
				}

				DrawLine( currentPoint[0], currentPoint[1], nextPoint[0], nextPoint[1] );
			}

			glEnd( );
		}
	}

	int CScreen::GetNearestPointsCount( Vector2DI point, Vector2dList vecNearestPoints )
	{
		int count;

		for( auto it = vecNearestPoints.begin(); it < vecNearestPoints.end(); it++ )
		{
			if( Vector2F( point - *it ).length( ) < fHypo )
			{
				count++;
			}
		}

		return count;
	}

	Vector2dList CScreen::GetNearestOppoCoords( CPointInfo pointInfo, PointInfoList vecPointInfo )
	{
		Vector2dList vecPoints;

		cml::vector2i currentPoint = pointInfo.GetPoint()->To2DVector();

		for( auto it = vecPointInfo.begin( ); it < vecPointInfo.end( ); it++ )
		{
			if( pointInfo.IsOppo( it->GetOwner( ) ) )
			{
				cml::vector2i nextPoint = it->GetPoint( )->To2DVector( );

				if( cml::vector2d( currentPoint - nextPoint ).length( ) <= fHypo )
				{
					vecPoints.push_back( nextPoint );
				}

				continue;
			}
		}

		return vecPoints;
	}

	void CScreen::RenderScene( )
	{
		glClear( GL_COLOR_BUFFER_BIT );

		DrawMesh( );
		DrawPlayersPoints( );
		DrawAreas( );

		glutSwapBuffers( );
	}

	void CScreen::UpdateScreen( int width, int heigth )
	{
		float fRatio;

		if( !heigth )
		{
			heigth = 1;
		}

		glViewport( 0, 0, width, heigth );
		glMatrixMode( GL_PROJECTION );

		glLoadIdentity( );

		fRatio = (float)width / (float)heigth;

		if( width <= heigth )
		{
			glOrtho( -100, 100, -100.0 / fRatio, 100.0 / fRatio, 1, -1 );
		}
		else
		{
			glOrtho( -100 * fRatio, 100 * fRatio, -100, 100, 1, -1 );
		}

		glMatrixMode( GL_MODELVIEW );
		glLoadIdentity( );
	}

	Vector2DI CScreen::GetNearestPoint( CPoint point )
	{
		return CScreen::GetNearestPoint( Vector2DI( point.GetX(), point.GetY() ) );
	}

	Vector2DI CScreen::GetNearestPoint( Vector2DI point )
	{
		Vector2DI nearest( 0, 0 );

		for( int i = CellSize; i < ScreenWidth; i += CellSize )
		{
			for( int k = CellSize; k < ScreenHeigth; k += CellSize )
			{
				Vector2DI newPoint( i, k );

				if( (newPoint - point).length( ) < ( nearest - point ).length( ) )
				{
					nearest = newPoint;
				}
			}
		}

		return nearest;
	}

	bool CScreen::HaveSamePoint( Vector2DI newPoint )
	{
		if( !CGlobals::m_vPointInfo.empty( ) )
		{
			for( auto it = CGlobals::m_vPointInfo.begin( ); it < CGlobals::m_vPointInfo.end( ); it++ )
			{
				Vector2DI oldPoint = it->GetPoint( )->To2DVector( );

				if( oldPoint == newPoint )
				{
					return true;
				}
			}
		}

		return false;
	}
}