using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

using Rmake.Framework.Logging;
using Rmake.Rendering.APIWrapper;
using Rmake.Rendering.ComponentLayer;

namespace Rmake.GameRendering
{
	/// <summary>
	/// Layerのクラス
	/// </summary>
	public class LayerView
	{
		private Hashtable renderingViewHash = null;
		private Hashtable renderingViewHashInvisible = null;
		private ArrayList tableMap = null;
		private int layerIndex;


		private int width = 32 * 640;	// マップの幅(Pixel単位)
		private int height = 32 * 480;
		private int chipWidth = 32;
		private int chipHeight = 32;

		private int tableWidth =  (32 * 640) / (32 * 8);	//テーブルの幅(セル数)
		private int tableHeight = (32 * 480) / (32 * 8);
		private int tablePieceWidth = 32 * 8;	//テーブルのピースの幅(Pixel単位)
		private int tablePieceHeight = 32 * 8;

		internal int Width
		{ get { return width; } }

		internal int Height
		{ get { return height; } }

		internal int ChipWidth
		{ get { return chipWidth; } }

		internal int ChipHeight
		{ get { return chipHeight; } }

		internal int TableWidth
		{ get { return tableWidth; } }

		internal int TableHeight
		{ get { return tableHeight; } }

		internal int TablePieceWidth
		{ get { return tablePieceWidth; } }

		internal int TablePieceHeight
		{ get { return tablePieceHeight; } }

		internal Hashtable RenderingViewHash
		{
			get { return renderingViewHash; }
		}

		internal Hashtable RenderingViewHashInvisible
		{
			get { return renderingViewHashInvisible; }
		}

		internal ArrayList TableMap
		{
			get { return tableMap; }
		}

		internal int LayerIndex
		{
			set { layerIndex = value; }
			get { return layerIndex; }
		}

		public LayerView()
		{
			renderingViewHash = new Hashtable();
			renderingViewHashInvisible = new Hashtable();

			SetSize(width, height, chipWidth, chipHeight);
		}

		internal bool SetSize(int width, int height, int chipWidth, int chipHeight)
		{
			this.width = width;
			this.height = height;
			this.chipWidth = chipWidth;
			this.chipHeight = chipHeight;

			this.tablePieceWidth = chipWidth * 8;
			this.tablePieceHeight = chipHeight * 8;
			this.tableWidth = width / this.tablePieceWidth;
			this.tableHeight = height / this.tablePieceHeight;

			int isz, jsz;
			isz = tableHeight;
			jsz = tableWidth;
			tableMap = new ArrayList();
			for(int i = 0 ; i < isz ; i++)
			{
				tableMap.Add(new ArrayList());

				for(int j = 0 ; j < jsz ; j++)
				{
					((ArrayList)tableMap[i]).Add(new Hashtable());
				}
			}

			return true;
		}

		internal void CleanUp()
		{
		
		}

		/// <summary>
		/// GameRenderingViewから派生したクラスのインスタンスを追加
		/// </summary>
		/// <param name="gameRenderingView">GameRenderingViewから派生したクラスのインスタンス</param>
		public void AddGameRenderingView(GameRenderingView gameRenderingView)
		{
			gameRenderingView.AddLayer(this);
			/*
			if(gameRenderingView.LayerVisible && gameRenderingView.Visible)
			{
				renderingViewHash.Add(gameRenderingView, gameRenderingView);
				//gameRenderingView.LayerIndex = 0;
			}
			else
			{
				renderingViewHashInvisible.Add(gameRenderingView, gameRenderingView);
				//gameRenderingView.LayerIndex = 0;
			}

			gameRenderingView.Layer = this;
			*/
		}

		/// <summary>
		/// GameRenderingViewから派生したクラスのインスタンスの削除
		/// </summary>
		/// <param name="gameRenderingView">GameRenderingViewから派生したクラスのインスタンス</param>
		public void RemoveGameRenderingView(GameRenderingView gameRenderingView)
		{
			gameRenderingView.RemoveLayer(this);
			/*
			gameRenderingView.Layer = null;
			gameRenderingView.LayerIndex = -1;

			renderingViewHash.Remove(gameRenderingView);
			renderingViewHashInvisible.Remove(gameRenderingView);
			*/
		}

		/// <summary>
		/// 登録されているGameRenderingViewから派生したクラスのインスタンスを
		/// すべて削除
		/// </summary>
		public void ClearGameRenderingView()
		{
			foreach(DictionaryEntry de in renderingViewHash)
			{
				GameRenderingView grv = (GameRenderingView)de.Value;

				grv.Layer = null;
				grv.LayerIndex = -1;
			}

			foreach(DictionaryEntry de in renderingViewHashInvisible)
			{
				GameRenderingView grv = (GameRenderingView)de.Value;

				grv.Layer = null;
				grv.LayerIndex = -1;
			}

			renderingViewHash.Clear();
			renderingViewHashInvisible.Clear();
		}

		/// <summary>
		/// 登録されているGameRenderingViewから派生したクラスのインスタンスを
		/// すべて消去
		/// </summary>
		/// <param name="manager"></param>
		public void DeleteGameRenderingView(GameRenderingManager manager)
		{
            ArrayList alist = new ArrayList();

			foreach(DictionaryEntry de in renderingViewHash)
			{
				GameRenderingView grv = (GameRenderingView)de.Value;

				//grv.Layer = null;
				//grv.LayerIndex = -1;

                alist.Add(grv);

				//manager.DeleteRenderingView(grv);
			}

			foreach(DictionaryEntry de in renderingViewHashInvisible)
			{
				GameRenderingView grv = (GameRenderingView)de.Value;

				//grv.Layer = null;
				//grv.LayerIndex = -1;

                alist.Add(grv);

				//manager.DeleteRenderingView(grv);
			}

            foreach (GameRenderingView grv in alist)
            {
                manager.DeleteRenderingView(grv);
            }

			renderingViewHash.Clear();
			renderingViewHashInvisible.Clear();
		}

		internal void Render(GameRenderingManager manager)
		{

			//
			int i, j;
			int ia, ja;
			Point lt = manager.CameraPosition;
			Point rb;

			rb = new Point(lt.X + manager.Width,
							lt.Y + manager.Height);

			lt.X /= TablePieceWidth;
			lt.Y /= TablePieceHeight;
			rb.X /= TablePieceWidth;
			rb.Y /= TablePieceHeight;

			for(i = lt.Y ; i <= rb.Y ; i++)
			{
				ia = i % TableHeight;
				if(ia < 0) ia += TableHeight;
				ArrayList tableList = (ArrayList)TableMap[ia];
				for(j = lt.X ; j <= rb.X ; j++)
				{
					ja = j % TableWidth;
					if(ja < 0) ja += TableWidth;
					Hashtable hash = (Hashtable)tableList[ja];

					foreach(DictionaryEntry de in hash)
					{
						GameRenderingView grv = 
							(GameRenderingView)de.Value;

						if(grv.Drawed == false)
						{
							grv.LayerVisible = true;
							//grv.LayerIndex = layerIndex;
							//grv.Render(manager);

							grv.Drawed = true;
						}

					}
				}
			}

			//
			foreach(DictionaryEntry de in renderingViewHash)
			{
				GameRenderingView grv = (GameRenderingView)de.Value;

				grv.LayerIndex = layerIndex;
				grv.Render(manager);

			}

		}

		internal void SetLayerMinus1(GameRenderingManager manager)
		{
			foreach(DictionaryEntry de in renderingViewHash)
			{
				GameRenderingView grv = (GameRenderingView)de.Value;

				grv.LayerIndex = -2;
			}

			//
			int i, j;
			int ia, ja;
			Point lt = manager.CameraPosition;
			Point rb;

			rb = new Point(lt.X + manager.Width,
				lt.Y + manager.Height);

			lt.X /= TablePieceWidth;
			lt.Y /= TablePieceHeight;
			rb.X /= TablePieceWidth;
			rb.Y /= TablePieceHeight;

			for(i = lt.Y ; i <= rb.Y ; i++)
			{
				ia = i % TableHeight;
				if(ia < 0) ia += TableHeight;
				ArrayList tableList = (ArrayList)TableMap[ia];
				for(j = lt.X ; j <= rb.X ; j++)
				{
					ja = j % TableWidth;
					if(ja < 0) ja += TableWidth;
					Hashtable hash = (Hashtable)tableList[ja];

					foreach(DictionaryEntry de in hash)
					{
						GameRenderingView grv = 
							(GameRenderingView)de.Value;

						grv.LayerVisible = false;
						grv.Drawed = false;
                        grv.LayerIndex = -2;

					}
				}
			}

		}

	}
}