using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.Globalization;
using Brains.Framework.QuadTree;
using Brains.Framework.Map;
using Brains.Framework.Utility;
using Brains.Framework.Behaviors.PathFinding;
using Brains.Framework.Grouping;
using Brains.Spatial;

namespace Brains.Framework
{
    /// <summary>
    /// Class represents a game World for the AI Engine.
    /// Contains Grids and Actors
    /// </summary>
    public class World
    {
        //
        //privates
        //
        private List<Agent> _agentsToRemove = new List<Agent>();
        private Texture2D _mapTexture;
        private WorldMap _map;
        internal SpatialTable _spatialtable;
        //
        //Public properties
        //
        /// <summary>
        /// Parent Engine
        /// </summary>
        public AIEngine Engine { get; set; }
        
        /// <summary>
        /// Gets or sets the list of Actors in the world
        /// </summary>
        public List<Agent> Actors = new List<Agent>();

        public Dictionary<int,Group> Groups { get; set; }

        /// <summary>
        /// Gets the world map
        /// </summary>
        public WorldMap Map { get { return _map; } }

        public World()
        {
            Groups = new Dictionary<int, Group>();
            
        }
        //
        //Public Methods
        //
        /// <summary>
        /// This method calls Update on all Actors. This can be overriden.
        /// </summary>
        /// <param name="gameTime">The GameTime elapsed since the last update</param>
        public virtual void Update(GameTime gameTime)
        {
            foreach (var item in Actors)
            {
                item.UpdatePerception(gameTime);
            }
            foreach (var item in Actors)
            {
                item.Update(gameTime);
            }
            if (_agentsToRemove.Count > 0)
            {
                for (int i = 0; i < _agentsToRemove.Count; i++)
                {
                    Actors.Remove(_agentsToRemove[i]);
                }
                _agentsToRemove.Clear();
            }
        }

        /// <summary>
        /// Initializes a new world map with the provides parameters
        /// </summary>
        /// <param name="width">The width of the map in pixels</param>
        /// <param name="height">The height of the map in pixels</param>
        /// <param name="cellsize">The size of a cells width or height</param>
        public void SetupMap(int width, int height, int cellsize)
        {
            SetupMap(width, height, cellsize, width / cellsize, height / cellsize,typeof(Grid));
        }
        protected static sbyte[,] direction = new sbyte[4, 2]
            { 
                { 0,-1} , 
                { 1, 0}, 
                { 0, 1}, 
                {-1, 0}
            };

        /// <summary>
        /// This method will create a game Map of the defined size and automatically cluster the map into grids
        /// </summary>
        /// <param name="width">The full width in pixels of the map</param>
        /// <param name="height">The full height in pixels of the map</param>
        /// <param name="cellsize">The width or height of a gridcell</param>
        /// <param name="maxclusterwidth">Maximum number of columns in any grid of the cluster</param>
        /// <param name="maxclusterheight"></param>
        internal void SetupMap(int width, int height, int cellsize, int maxclusterwidth,int maxclusterheight,Type gridType)
        {
            _map = new WorldMap(width,height);
            int totalCols = width / cellsize;
            int totalRows= height / cellsize;
            int clusterRows = totalCols / maxclusterwidth;
            int clusterCols = totalRows/ maxclusterheight;
            _map.ClusterGrid.Setup(clusterRows, clusterCols);
            _spatialtable = new SpatialTable();
            _spatialtable.Setup(width, height, cellsize);

            Vector2 position = new Vector2();
            for (int y = 0; y < clusterRows; y++)
            {
                for (int x = 0; x < clusterCols; x++)
                {

                    Grid grid = (Grid)gridType.Assembly.CreateInstance(gridType.FullName);
                    grid.Setup(position, maxclusterwidth * cellsize, maxclusterheight * cellsize, cellsize);
                    //Grid grid = (Grid)gridType.Assembly.CreateInstance(
                    //    gridType.FullName,
                    //    true,
                    //    System.Reflection.BindingFlags.CreateInstance,
                    //    null,
                    //    new object[] { 
                    //        position,
                    //        maxclusterwidth * cellsize, 
                    //        maxclusterheight* cellsize,  
                    //        cellsize },
                    //    CultureInfo.CurrentCulture,
                    //    null);

                    grid.Initialize();
                    position.X += maxclusterwidth * cellsize;
                    Map.AddGrid(grid);
                }
                position.Y += maxclusterheight * cellsize;
                position.X = 0;
            }
            
        }
       
        public void AnotateMap()
        {
            List<QuadTreePositionItem<GridCell>> list = new List<QuadTreePositionItem<GridCell>>();
            Map.GridCellTree.GetAllItems(ref list);
            //Grid grid = Map.Cluster[index];
            //Annotate clearance.
            int rows = Map.ClusterGrid.Rows;
            int cols= Map.ClusterGrid.Cols;
            Cluster cluster = Map.ClusterGrid;
            for (int xx = cluster.TotalCols - 1; xx >= 0; xx--)
            {
                for (int yy = cluster.TotalRows - 1; yy >= 0; yy--)
                {
                    //int x = xx / Map.Cluster[0].Cols;
                    //int y = yy/ Map.Cluster[0].Rows;
                    //int index = y * Map.Cols + x;
                    //Grid grid = Map.Cluster[index];

                    int index = yy * cluster.TotalCols + xx;
                    GridCell cell = Map.AllCells[index];// grid.GetCell(xx - (x * grid.Cols), yy - (y * grid.Rows));
                    if (cell.Type == 0) //If the cell is not traversable, bail out.
                        continue;
                    
                    //Get adjacent tiles
                    GridCell c1, c2, c3;
                    int y = (index - (index % cluster.TotalCols)) / cluster.TotalCols;
                    int x = index % cluster.TotalCols;
                    int newindex = (y + 1) * cluster.TotalCols + (x + 1);
                    c1 = null;
                    c2 = null;
                    c3 = null;
                    if(Map.AllCells.Count > newindex)
                        c1 = Map.AllCells[newindex];// grid.GetCell(cell.X + 1, cell.Y + 1);

                    newindex = (y) * cluster.TotalCols + (x + 1);
                    if (Map.AllCells.Count > newindex)
                        c2 = Map.AllCells[newindex]; //grid.GetCell(cell.X + 1, cell.Y);
                    newindex = (y + 1) * cluster.TotalCols + (x);
                    if (Map.AllCells.Count > newindex)
                        c3 = Map.AllCells[newindex]; //grid.GetCell(cell.X, cell.Y + 1);
                    
                    //If all tiles are valid
                    if (c1 != null && c2 != null && c3 != null)
                    {

                        int min = c1.Labels[AIConsts.CLEARANCEVALUE];
                        min = c2.Labels[AIConsts.CLEARANCEVALUE] < min ? c2.Labels[AIConsts.CLEARANCEVALUE] : min;
                        min = c3.Labels[AIConsts.CLEARANCEVALUE] < min ? c3.Labels[AIConsts.CLEARANCEVALUE] : min;
                        cell.Labels[AIConsts.CLEARANCEVALUE] = min + 1; // NB: +1 for minimum tile clearance

                    }
                    else
                    {
                        for (int i = 1; i < 3; i++)
                        {
                            int v = i & cell.Type;
                            if (v == cell.Type)
                                cell.Labels[AIConsts.CLEARANCEVALUE] = 1;
                            else
                                cell.Labels[AIConsts.CLEARANCEVALUE] = 0;
                        }
                        //Otherwise it must be up against a non traversable tile.

                    }



                }
            }
                        
            if (cluster.Grids.Count > 1)
            {
                int index = 0;
                for (int y = 0; y < rows; y++)
                {
                    for (int x = 0; x < cols; x++)
                    {
                        SetHorizontalEntrancesOnGrid(x, y);
                        SetVerticalEntrancesOnGrid(x, y);
                        ////Check right edge
                        //if (cluster.Grids.Count > index + 1)
                        //{
                        //    for (int row = 0; row < cluster.Grids[index].Rows; row++)
                        //    {
                        //        GridCell leftcell = cluster.Grids[index].GetCell(
                        //                        cluster.Grids[index].Cols - 1,
                        //                        row);
                        //        GridCell rightcell = cluster.Grids[index + 1].GetCell(
                        //                        0,
                        //                        row);

                        //        if (leftcell.Type != AIConsts.BLOCKED_TILE &&
                        //            rightcell.Type != AIConsts.BLOCKED_TILE)
                        //        {
                        //            //leftcell.Labels[AIConsts.ISVALIDCLUSTEREDGE] = 1;
                        //            //rightcell.Labels[AIConsts.ISVALIDCLUSTEREDGE] = 1;
                        //        }
                        //    }
                        //}

                        ////check left edge

                        //if (index > 1)
                        //{
                        //    for (int row = 0; row < cluster.Grids[index].Rows; row++)
                        //    {
                        //        GridCell leftcell = cluster.Grids[index - 1].GetCell(
                        //                            cluster.Grids[index - 1].Cols - 1,
                        //                            row);
                        //        GridCell rightcell = cluster.Grids[index].GetCell(
                        //                        0,
                        //                        row);

                        //        if (leftcell.Type != AIConsts.BLOCKED_TILE &&
                        //            rightcell.Type != AIConsts.BLOCKED_TILE)
                        //        {
                        //            //leftcell.Labels[AIConsts.ISVALIDCLUSTEREDGE] = 1;
                        //            //rightcell.Labels[AIConsts.ISVALIDCLUSTEREDGE] = 1;
                        //        }
                        //    }
                        //}

                        ////check bottom edge

                        //if (index + cols < cluster.Grids.Count)
                        //{
                        //    for (int col = 0; col < cluster.Grids[index].Cols; col++)
                        //    {
                        //        GridCell topcell = cluster.Grids[index].GetCell(
                        //                        col,
                        //                        cluster.Grids[index].Rows - 1);
                        //        GridCell bottomcell = cluster.Grids[index + cols].GetCell(
                        //                        col,
                        //                        0);

                        //        if (topcell.Type != AIConsts.BLOCKED_TILE &&
                        //            bottomcell.Type != AIConsts.BLOCKED_TILE)
                        //        {
                        //          //  bottomcell.Labels[AIConsts.ISVALIDCLUSTEREDGE] = 1;
                        //          //  topcell.Labels[AIConsts.ISVALIDCLUSTEREDGE] = 1;
                        //        }
                        //    }
                        //}
                        ////Check Top
                        //if (index - cols > 0)
                        //{
                        //    for (int col = 0; col < cluster.Grids[index].Cols; col++)
                        //    {
                        //        GridCell topcell = cluster.Grids[index - cols].GetCell(
                        //                        col,
                        //                        cluster.Grids[index - cols].Rows - 1);
                        //        GridCell bottomcell = cluster.Grids[index].GetCell(
                        //                        col,
                        //                        0);

                        //        if (topcell.Type != AIConsts.BLOCKED_TILE &&
                        //            bottomcell.Type != AIConsts.BLOCKED_TILE)
                        //        {
                        //            //bottomcell.Labels[AIConsts.ISVALIDCLUSTEREDGE] = 1;
                        //            //topcell.Labels[AIConsts.ISVALIDCLUSTEREDGE] = 1;
                        //        }
                        //    }
                        //}
                        index++;
                    }
                }
            }


            //Precalculate paths for each grid transition
            int gridIndex = 0;
            foreach (var item in Map.ClusterGrid.Grids)
            {
                
                int y = (gridIndex - (gridIndex % Map.ClusterGrid.Cols)) / Map.ClusterGrid.Cols;
                int x = gridIndex % Map.ClusterGrid.Cols;
                //North To East
                if (y > 0 && x < Map.ClusterGrid.Cols - 1)
                {
                    PredeterminePaths(item,x, y - 1, x + 1, y);
                }
                //East To South
                if (x < Map.ClusterGrid.Cols - 1 && y<Map.ClusterGrid.Rows-1)
                {
                    PredeterminePaths(item, x + 1, y, x, y + 1);
                }
                //South To West
                if (y < Map.ClusterGrid.Rows - 1 && x > 0)
                {
                    PredeterminePaths(item, x, y + 1, x - 1, y);
                }
                //West To Nort
                if (x>0 && y>0)
                {
                    PredeterminePaths(item, x - 1, y, x, y - 1);
                }

                //West To East
                if (x > 0 && x < Map.ClusterGrid.Cols-1)
                {
                    PredeterminePaths(item, x - 1, y, x + 1, y);
                }

                //North To South
                if (y > 0 && y < Map.ClusterGrid.Rows- 1)
                {
                    PredeterminePaths(item, x, y - 1, x, y + 1);
                }
                gridIndex++;
            }


            //Cluster cl = Map.ClusterGrid;
            //int index1 = 0;


            //foreach (var item in Map.ClusterGrid.Grids)
            //{
            //    int y = (index1 - (index1 % cl.Cols)) / cl.Cols;
            //    int x = index1 % cl.Cols;

            //    //Top To Right
            //    if (y > 0 && x < cl.Cols - 1)
            //    {
            //        int indexF = (y-1) * cl.Cols + x ;
            //        int indexT = y * cl.Cols + (x+1);
            //        GridCell from;
            //        GridCell to;

            //        from = GetFreeCellAt(item, Direction.up);
            //        to = GetFreeCellAt(item, Direction.rigth);
            //        if(from!=null&& to!=null)
            //            CalculatePath(from, to,indexF,indexT);
            //    }
            //    //Right To Bottom
            //    if (y < cl.Rows - 1 && x < cl.Cols - 1)
            //    {
            //        int indexF = y * cl.Cols + (x + 1);
            //        int indexT = (y + 1) * cl.Cols + x;
            //        GridCell from;
            //        GridCell to;

            //        from = GetFreeCellAt(item, Direction.rigth);
            //        to = GetFreeCellAt(item, Direction.down);
            //        if (from != null && to != null)
            //            CalculatePath(from, to, indexF, indexT);
            //    }
            //    //Bottom To Left
            //    if (y < cl.Rows - 1 && x > 0)
            //    {
            //        int indexF = (y + 1) * cl.Cols + x;
            //        int indexT = y * cl.Cols + (x - 1);
            //        GridCell from;
            //        GridCell to;

            //        from = GetFreeCellAt(item, Direction.down);
            //        to = GetFreeCellAt(item, Direction.left);
            //        if (from != null && to != null)
            //            CalculatePath(from, to, indexF, indexT);
            //    }
            //    //Left To Top
            //    if (y > 0 && x > 0)
            //    {
            //        int indexF = y * cl.Cols + (x-1);
            //        int indexT = (y-1) * cl.Cols + x;
            //        GridCell from;
            //        GridCell to;

            //        from = GetFreeCellAt(item, Direction.left);
            //        to = GetFreeCellAt(item, Direction.up);
            //        if (from != null && to != null)
            //            CalculatePath(from, to, indexF, indexT);
            //    }
            //    //Top to bottom
            //    if (y > 0 && y < cl.Rows - 1)
            //    {
            //        int indexF = (y - 1) * cl.Cols + x;
            //        int indexT = (y + 1) * cl.Cols + x;
            //        GridCell from;
            //        GridCell to;

            //        from = GetFreeCellAt(item, Direction.up);
            //        to = GetFreeCellAt(item, Direction.down);
            //        if (from != null && to != null)
            //            CalculatePath(from, to, indexF, indexT);
            //    }
            //    //Left To Right
            //    if (x > 0 && x < cl.Cols - 1)
            //    {
            //        int indexF = y * cl.Cols + (x - 1);
            //        int indexT = y * cl.Cols + (x + 1);
            //        GridCell from;
            //        GridCell to;

            //        from = GetFreeCellAt(item, Direction.left);
            //        to = GetFreeCellAt(item, Direction.rigth);
            //        if (from != null && to != null)
            //            CalculatePath(from, to,indexF,indexT);
            //    }

            //    index1++;
            //}
        }

        private void PredeterminePaths(Grid grid,int x1,int y1,int x2,int y2)
        {

            int indexF = Map.ClusterGrid.GetGridIndex(x1, y1);
            int indexT = Map.ClusterGrid.GetGridIndex(x2, y2);

            Grid gridA = Map.ClusterGrid.GetGrid(x1, y1);
            GridCell cellA= GetValidCellFromEntrance(gridA,grid);

            Grid gridB= Map.ClusterGrid.GetGrid(x2, y2);
            GridCell cellB = GetValidCellFromEntrance(gridB, grid);

            if (cellB != null && cellA != null)
            {
                CalculatePath(
                    grid.GetCell(cellA.X,cellA.Y),
                    grid.GetCell(cellB.X, cellB.Y), 
                    indexF, 
                    indexT);
            }
        }

        private GridCell GetValidCellFromEntrance(Grid fromGrid,Grid toGrid)
        {
            foreach (var entrance in Map.ClusterGrid.Entrances)
            {
                if (entrance.CellA.Parent == fromGrid && entrance.CellB.Parent==toGrid)
                    return entrance.CellB;
                if (entrance.CellB.Parent == fromGrid && entrance.CellA.Parent == toGrid)
                    return entrance.CellA;
            }
            return null;
        }

        private void SetVerticalEntrancesOnGrid(int x, int y)
        {
            bool checkEast = false;
            bool checkWest = false;

            Grid thisGrid = Map.ClusterGrid.GetGrid(x, y);

            if (x > 0)
                checkWest= true;

            if (x < Map.ClusterGrid.Cols- 1)
                checkEast = true;

            if (checkEast)
            {
                Grid eastGrid = Map.ClusterGrid.GetGrid(x+1, y);
                SetVertEntranceBetweenGrids(thisGrid, eastGrid);
            }
            if (checkWest)
            {
                Grid westGrid= Map.ClusterGrid.GetGrid(x-1, y);
                SetVertEntranceBetweenGrids(thisGrid, westGrid);
            }
        }

        private void SetVertEntranceBetweenGrids(Grid gridA, Grid gridB)
        {
            int yIndexa = 0;
            int yIndexb = gridA.Cols- 1;
            if (gridB.Position.X > gridA.Position.X)
            {
                yIndexa = yIndexb;
                yIndexb = 0;
            }
            //Start near the middle
            int startRow = gridA.Rows/ 2;
            //Currently supports 1 transition per set of grids
            bool continueChecking = true;
            //Loop to end ignoring the corner cell
            for (int i = startRow; i < gridA.Rows - 1; i++)
            {

                GridCell _edgeCell = gridA.GetCell(yIndexa,i);
                GridCell _adjacentCell = gridB.GetCell(yIndexb,i);
                if (_edgeCell.Labels[AIConsts.BLOCKED_TILE] == 0 &&
                    _adjacentCell.Labels[AIConsts.BLOCKED_TILE] == 0)
                {
                    Map.ClusterGrid.AddEntrance(_edgeCell, _adjacentCell);
                    continueChecking = false;
                    break;
                }
            }
            if (continueChecking)
            {
                //Loop to beginning column ignoring the corner cell
                for (int i = startRow; i > 0; i--)
                {
                    GridCell _edgeCell = gridA.GetCell(yIndexa, i);
                    GridCell _adjacentCell = gridB.GetCell(yIndexb, i);
                    if (_edgeCell.Labels[AIConsts.BLOCKED_TILE] == 0 && _adjacentCell.Labels[AIConsts.BLOCKED_TILE] == 0)
                    {
                        Map.ClusterGrid.AddEntrance(_edgeCell, _adjacentCell);
                        continueChecking = false;
                        break;
                    }
                }
            }

        }
        
        private void SetHorizontalEntrancesOnGrid(int x, int y)
        {
            bool checkNorth = false;
            bool checkSouth = false;

            Grid thisGrid = Map.ClusterGrid.GetGrid(x,y);
            
            if (y > 0)
                checkNorth = true;
            
            if (y < Map.ClusterGrid.Rows-1)
                checkSouth= true;

            if (checkNorth)
            {
                Grid northGrid = Map.ClusterGrid.GetGrid(x, y - 1);
                SetHorizEntranceBetweenGrids(thisGrid, northGrid);
            }
            if (checkSouth)
            {
                Grid southGrid = Map.ClusterGrid.GetGrid(x, y + 1);
                SetHorizEntranceBetweenGrids(thisGrid, southGrid);
            }
            

        }

        private void SetHorizEntranceBetweenGrids(Grid gridA, Grid gridB)
        {
            int yIndexa = 0;
            int yIndexb = gridA.Rows - 1;
            if (gridB.Position.Y > gridA.Position.Y)
            {
                yIndexa = yIndexb;
                yIndexb = 0;
            }
            //Start near the middle
            int startCol = gridA.Cols / 2;
            //Currently supports 1 transition per set of grids
            bool continueChecking = true;
            //Loop to end ignoring the corner cell
            for (int i = startCol; i < gridA.Cols - 1; i++)
            {
                
                GridCell _edgeCell = gridA.GetCell(i, yIndexa);
                GridCell _adjacentCell = gridB.GetCell(i, yIndexb);
                if (_edgeCell.Labels[AIConsts.BLOCKED_TILE] == 0 && 
                    _adjacentCell.Labels[AIConsts.BLOCKED_TILE] == 0)
                {
                    Map.ClusterGrid.AddEntrance(_edgeCell, _adjacentCell);
                    continueChecking = false;
                    break;
                }
            }
            if (continueChecking)
            {
                //Loop to beginning column ignoring the corner cell
                for (int i = startCol; i > 0; i--)
                {
                    GridCell _edgeCell = gridA.GetCell(i, yIndexa);
                    GridCell _adjacentCell = gridB.GetCell(i, yIndexb);
                    if (_edgeCell.Labels[AIConsts.BLOCKED_TILE] == 0 && _adjacentCell.Labels[AIConsts.BLOCKED_TILE] == 0)
                    {
                        Map.ClusterGrid.AddEntrance(_edgeCell, _adjacentCell);
                        continueChecking = false;
                        break;
                    }
                }
            }


        }

        private void CalculatePath(GridCell from, GridCell to,int gridfrom,int gridto)
        {
            PathFinding.PathFinder _f = new Brains.Framework.PathFinding.PathFinder();
            _f.Grid = from.Parent;
            _f.StartNode = from;
            _f.EndNode = to;
            _f.Reset();

            while (_f.State == Brains.Framework.PathFinding.PathFinderState.Working)
            {
                _f.Iterate();
            }
            if (_f.State == Brains.Framework.PathFinding.PathFinderState.Finished)
            {
                // copying nodes
                PreStoredPath _path = new PreStoredPath();
                _path.Nodes = new List<StoredPathNode>();
                
                int counter = 0;
                //for (int index = pathFinder.closeList.Count - 1; index >= 0; index--)
                for (int index = 0; index <= _f.closeList.Count - 1; index++)
                {
                    StoredPathNode newNode = new StoredPathNode();
                    Grid grid = from.Parent;
                    GridCell _node = grid.GetCell(_f.closeList[index].X,
                                            _f.closeList[index].Y);
                    newNode.nodePosition.X = grid.GetCell(_f.closeList[index].X,
                                            _f.closeList[index].Y).Position.X;
                    newNode.nodePosition.Y = grid.GetCell(_f.closeList[index].X,
                                            _f.closeList[index].Y).Position.Y;
                    newNode.X = _f.closeList[index].X;
                    newNode.Y = _f.closeList[index].Y;


                    _path.FromGrid =gridfrom;
                    _path.ToGrid = gridto;
                    //pathNodes[counter] = newNode;
                    _path.Nodes.Add(newNode);
                    counter++;
                }


                from.Parent.PredeterminedPaths.Add(_path);
            }
            if (_f.State == Brains.Framework.PathFinding.PathFinderState.Failed)
            {
                Console.WriteLine("");
            }

        }
        
        /// <summary>
        /// Adds the specified Actor to the Actors collection
        /// </summary>
        /// <param name="actor">The Actor to add</param>
        public void AddActor(Agent actor)
        {
            actor.ParentWorld = this;
            Actors.Add(actor);
            _spatialtable.RegisterObject(actor);
        }
        /// <summary>
        /// Loads Map data from a texture
        /// </summary>
        /// <param name="texture">The texture to use</param>
        /// <param name="cellSize">The size of a cells width or height</param>
        /// <param name="grid">The type of grid to create</param>
        public void LoadMapDataFromTexture(Texture2D texture, int cellSize,Type grid)
        {
            LoadMapDataFromTexture(texture, 1, 1, cellSize, grid);
        }
        /// <summary>
        /// Loads Map data from a texture
        /// </summary>
        /// <param name="texture">The texture to use</param>
        /// <param name="cellSize">The size of a cells width or height</param>
        public void LoadMapDataFromTexture(Texture2D texture, int cellSize)
        {
            LoadMapDataFromTexture(texture, 1, 1, cellSize, typeof(Grid));
        }
        /// <summary>
        /// Loads Map data from a texture
        /// </summary>
        /// <param name="texture">The texture to use</param>
        /// <param name="cellSize">The size of a cells width or height</param>
        /// <param name="cols">The number of cols to split the map into</param>
        /// <param name="rows">The number of rows to split the map into</param>
        /// <param name="gridType">The type of grid to create</param>
        public void LoadMapDataFromTexture(Texture2D texture, int clusterColumnSplit, int clusterRowSplit, int cellSize, Type gridType)
        {
            _mapTexture = texture;

            Vector2 position = new Vector2();
            int clusterCols = texture.Width / clusterColumnSplit;
            int clusterRows = texture.Height / clusterRowSplit;

            SetupMap(
                texture.Width * cellSize,
                texture.Height * cellSize,
                cellSize,
                clusterCols,
                clusterRows,
                gridType);

            int index = 0;
            for (int y = 0; y < clusterRowSplit; y++)
            {
                for (int x = 0; x < clusterColumnSplit; x++)
                {
                    Grid item = Map.ClusterGrid.Grids[index];
                    index++;

                    int count = item.Rows * item.Cols;
                    Color[] colorData = new Color[count];
                    texture.GetData<Color>(
                        0,
                        new Rectangle(x * clusterCols, y * clusterRows, clusterCols, clusterRows),
                        colorData,
                        0,
                        count);
                    item.ColorData = colorData;
                    int _index = 0;
                    for (int yy = 0; yy < item.Rows; yy++)
                    {
                        for (int xx = 0; xx < item.Cols; xx++)
                        {
                           
                            GridCell cell = item.GetCell(xx, yy);
                            cell.Labels[AIConsts.COLORR] = colorData[_index].R;
                            cell.Labels[AIConsts.COLORG] = colorData[_index].G;
                            cell.Labels[AIConsts.COLORB] = colorData[_index].B;
                            cell.Labels[AIConsts.COLORA] = colorData[_index].A;

                            if (colorData[_index] == Color.Black)
                            {
                                cell.Type = 0;
                            }
                            //HACK FOR WATER
                            if (colorData[_index] == new Color(0,17,255))
                            {
                                cell.Type = 2;
                            }
                            _index++;
                        }
                    }
                }
            }

            AnotateMap();
        }

        /// <summary>
        /// Adds an Actor to the Actors collection at the specified position and size
        /// </summary>
        /// <param name="position">The position to start the Actor at</param>
        /// <param name="radius">The radius of the Actor</param>
        /// <returns></returns>
        public Agent AddActor(Vector2 position, float radius)
        {
            Agent _actor = new Agent(position, radius);
            AddActor(_actor);
            return _actor;
        }
        
        /// <summary>
        /// Removes an Agent from the world
        /// </summary>
        /// <param name="agent"></param>
        public void RemoveAgent(Agent agent)
        {
            _agentsToRemove.Add(agent);
        }

        public void AddGroup(Group group)
        {
            Groups.Add(group.GroupID, group);
        }

        public Group GetGroup(int id)
        {
            return Groups[id];
        }
    }
}