/**
*   Copyright: © 2012-2014 Anton Gushcha
*   License: Subject to the terms of the MIT license, as written in the included LICENSE file.
*   Authors:  NCrashed <ncrashed@gmail.com>,
*             LeMarwin <lemarwin42@gmail.com>,
*             Nazgull09 <nazgull90@gmail.com>
*/
module ant.world;

import devol.world;
import ant.progtype;
import ant.operators;
import core.thread;
import core.time;

import std.random;
import std.stdio;
import std.process;
import ant.app;

import derelict.sdl2.sdl;

class AntWorld: WorldAbstract
{
	void initialize()
	{	
		zeros();
		generateMap();
		print();
	}	
	static immutable int size = 18;	
	static int Food=25;
	
	const bool[size][size] getMap()
	{
		return map;
	}
	
	private:
	
	bool[size][size] map;
	
	public:
	

	bool checkForFood(int x, int y)
	{
		if (x>=size || y>=size) return false;
		
		return map[x][y];
	}
	void removeFood(int x, int y)
	{
		map[x][y]=false;
	}
	
	void generateMap()
	{
//		writeln("Generating map");
		Ant Grower = new Ant;
		
		Grower.x = size/2+uniform!"[]"(-1,1);
		Grower.y = size/2+uniform!"[]"(-1,1);
		
		Grower.Direction = cast(Ant.Faces)uniform!"[]"(cast(uint)Ant.Faces.min, cast(uint)Ant.Faces.max);
		
		int FC = 1;
		int breakCount = 0;
		
		//writeln("Adding delegate");
		Grower.addCheat(delegate bool ()
		{
			final switch(Grower.Direction)
			{
			case Grower.Faces.NORTH:
				if(Grower.y>=2)
				return checkForFood(Grower.x,Grower.y-2)||checkForFood(Grower.x,Grower.y-1)
						||checkForFood(Grower.x-1,Grower.y-2)||checkForFood(Grower.x-1,Grower.y-1)
						||checkForFood(Grower.x+1,Grower.y-2)||checkForFood(Grower.x+1,Grower.y-1);
				break;
			case Grower.Faces.SOUTH:
				if(Grower.y<=size-2)
				return checkForFood(Grower.x,Grower.y+2)||checkForFood(Grower.x,Grower.y+1)
						||checkForFood(Grower.x-1,Grower.y+2)||checkForFood(Grower.x-1,Grower.y+1)
						||checkForFood(Grower.x+1,Grower.y+2)||checkForFood(Grower.x+1,Grower.y+1);
				break;
			case Grower.Faces.EAST:
				if(Grower.x<=size-2)
				return checkForFood(Grower.x+2,Grower.y)||checkForFood(Grower.x+1,Grower.y)
						||checkForFood(Grower.x+2,Grower.y-1)||checkForFood(Grower.x+1,Grower.y-1)
						||checkForFood(Grower.x+2,Grower.y+1)||checkForFood(Grower.x+1,Grower.y+1);
				break;
			case Grower.Faces.WEST:
				if(Grower.x>=2)
				return checkForFood(Grower.x-2,Grower.y)||checkForFood(Grower.x-1,Grower.y)
						||checkForFood(Grower.x-2,Grower.y-1)||checkForFood(Grower.x-1,Grower.y-1)
						||checkForFood(Grower.x-2,Grower.y+1)||checkForFood(Grower.x-1,Grower.y+1);
				break;
			}
			return false;
		});
		//writeln("Placing food");
		auto flag = true;
		while(FC!=Food && breakCount < 100)
		{
			//writeln("FC = ", FC);
			//writeln("Food = ", Food);
			int c = uniform!"[]"(0,1);
			GoForward F = new GoForward;
			TurnLeft L = new TurnLeft;
			TurnRight R = new TurnRight;
			//writeln("Choosing direction");
			if(c&&!Grower.MyCheat())
			{
				//writeln("Forward");
				F.apply(Grower, null, this);
				
				int d = uniform!"[]"(0,1);
				//writeln("Chance to place food: ", d);
				if ( Grower.x >= 1 && Grower.y  >= 1 && Grower.x <= size-1 && Grower.y <= size - 1 )
				{
    				if((d||flag)&&!map[Grower.x][Grower.y])
    				{
    					//writeln("Placing food");
    					map[Grower.x][Grower.y] = true;
    					FC++;
    					flag = false;
    				}
    				else
    				{
    					flag = true;
    				}
				}
			}
			else
			{
				//writeln("Rotating");
				breakCount++;
				int d = uniform!"[]"(0,1);
				if(d)
				{
					//writeln("Left");
					L.apply(Grower, null, this);
				}
				else
				{
					//writeln("Right");
					R.apply(Grower,null,this);
				}
			}
			

			
			void printGr()
			{
                version(NoGraphicsOutput)
                {
                    
                } else
                {
    				//writeln("Getting singleton");
    				auto app = App.getSingleton();
    				assert(app !is null);
    				
    				app.clear();
    				draw(app, app.food, app.empty, app.wall);
    				app.draw(app.ants[Grower.Direction], 32u*(Grower.x+1), 32u*(Grower.y+1), 32u, 32u);
    				app.present();
				}
			}
			
			printGr();
		}
	}
		void zeros()
		{
			foreach(ref line; map)
			{
				foreach(ref cell; line)
				{
					cell = false;
				}
			}
		}
	
	void print()
	{
//		version(linux)
//		{
//			system("clear");
//		}
//		foreach( l; map )
//		{
//			foreach( c; l)
//			{
//				if (c)
//					write("x");
//				else
//					write("-");
//			}
//			writeln();
//		}
	}
	
	void draw(App app, SDL_Texture* food, SDL_Texture* empty, SDL_Texture* wall)
	{
        version(NoGraphicsOutput)
        {
            
        } else
        {
    		assert(food !is null);
    		assert(empty !is null);
    		
    		foreach(uint j, l; map )
    		{
    			foreach(uint i, c; l)
    			{
    				if (c)
    				{
    					//writeln("drawing food at ", (j+1)*32u, " ", (i+1)*32u);
    					app.draw(food, (j+1)*32u , (i+1)*32u, 32u, 32u);
    				}
    				else
    				{	
    					//writeln("drawing empty at ", (j+1)*32u, " ", (i+1)*32u);
    					app.draw(empty, (j+1)*32u , (i+1)*32u, 32u, 32u);
    				}
    			}
    		}		
    		
    		foreach(uint i; 0..map.length+2)
    			app.draw(wall, i*32u, 0, 32u, 32u);
    		foreach(uint i; 0..map.length+2)
    			app.draw(wall, i*32u, (cast(uint)map.length+1)*32u, 32u, 32u);
    		foreach(uint i; 0..map.length+2)
    			app.draw(wall, 0, i*32u, 32u, 32u);				
    		foreach(uint i; 0..map.length+2)
    			app.draw(wall, (cast(uint)map.length+1)*32u, i*32u, 32u, 32u);	
		}
	}
	
	}