//#define ARM_DEBUG

namespace GarboDev
{
	using System;
	using System.IO;
	using System.Threading;
	using System.Timers;
	using System.Windows.Forms;
	using System.Collections.Generic;

	using BizHawk.Emulation;
	using BizHawk;

	public class GbaManager : IEmulator, ISyncSoundProvider, IVideoProvider
	{
		public const int cpuFreq = 16 * 1024 * 1024;

		private int framesRendered;

		private Arm7Processor arm7 = null;
		private Memory memory = null;
		private VideoManager videoManager = null;
		private SoundManager soundManager = null;

		private bool skipBios = false;

		public delegate void CpuUpdateDelegate(Arm7Processor processor, Memory memory);
		private event CpuUpdateDelegate onCpuUpdate = null;

		public Arm7Processor Arm7
		{
			get { return this.arm7; }
		}

		public VideoManager VideoManager
		{
			get { return this.videoManager; }
		}

		public SoundManager SoundManager
		{
			get { return this.soundManager; }
		}

		public Memory Memory
		{
			get { return this.memory; }
		}

		public Dictionary<uint, bool> Breakpoints
		{
			get { return this.arm7.Breakpoints; }
		}

		public ushort KeyState
		{
			get
			{
				if (this.memory != null)
				{
					return this.memory.KeyState;
				}

				return 0x3FF;
			}

			set
			{
				this.arm7.KeyState = value;
			}
		}

		public int FramesRendered
		{
			get { return this.framesRendered; }
			set { this.framesRendered = value; }
		}

		public event CpuUpdateDelegate OnCpuUpdate
		{
			add
			{
				this.onCpuUpdate += value;
				this.onCpuUpdate(this.arm7, this.memory);
			}
			remove
			{
				this.onCpuUpdate -= value;
			}
		}

		public bool SkipBios
		{
			get { return this.skipBios; }
			set { this.skipBios = value; }
		}

		public GbaManager(CoreComm comm)
		{
			_corecomm = comm;

			this.memory = new Memory();
			this.arm7 = new Arm7Processor(this.memory);
			this.videoManager = new VideoManager(this);
			this.videoManager.Memory = this.memory;
			this.soundManager = new SoundManager(this.memory, 44100);
		
			this.framesRendered = 0;
			Renderer renderer = new Renderer();
			renderer.Initialize(null);
			VideoManager.Renderer = renderer;

			videoManager.Presenter = delegate(uint[] data)
			{
				Buffer.BlockCopy(data, 0, this.vbuf, 0, 240 * 160 * 4);
			};
		}

		public void Load(byte[] rom, byte[] bios)
		{
			LoadBios(bios);
			LoadRom(rom);
		}

		public void Reset()
		{
			//this.Halt();

			this.arm7.Reset(this.skipBios);
			this.memory.Reset();
			this.videoManager.Reset();
		}

		public void LoadState(BinaryReader state)
		{
		}

		public void SaveState(BinaryWriter state)
		{
			state.Write("GARB");
		}

		public void LoadBios(byte[] biosRom)
		{
			this.memory.LoadBios(biosRom);

			if (this.onCpuUpdate != null)
			{
				this.onCpuUpdate(this.arm7, this.memory);
			}
		}

		public void LoadRom(byte[] cartRom)
		{
			//this.Halt();
			
			/*
			byte[] logo = new byte[]
                    {
            			0x24,0xff,0xae,0x51,0x69,0x9a,0xa2,0x21,
            			0x3d,0x84,0x82,0x0a,0x84,0xe4,0x09,0xad,
            			0x11,0x24,0x8b,0x98,0xc0,0x81,0x7f,0x21,
            			0xa3,0x52,0xbe,0x19,0x93,0x09,0xce,0x20,
	    	        	0x10,0x46,0x4a,0x4a,0xf8,0x27,0x31,0xec,
        	    		0x58,0xc7,0xe8,0x33,0x82,0xe3,0xce,0xbf,
	        	    	0x85,0xf4,0xdf,0x94,0xce,0x4b,0x09,0xc1,
		        	    0x94,0x56,0x8a,0xc0,0x13,0x72,0xa7,0xfc,
    		    	    0x9f,0x84,0x4d,0x73,0xa3,0xca,0x9a,0x61,
        		    	0x58,0x97,0xa3,0x27,0xfc,0x03,0x98,0x76,
	        		    0x23,0x1d,0xc7,0x61,0x03,0x04,0xae,0x56,
    		        	0xbf,0x38,0x84,0x00,0x40,0xa7,0x0e,0xfd,
	    		        0xff,0x52,0xfe,0x03,0x6f,0x95,0x30,0xf1,
            			0x97,0xfb,0xc0,0x85,0x60,0xd6,0x80,0x25,
	            		0xa9,0x63,0xbe,0x03,0x01,0x4e,0x38,0xe2,
		        	    0xf9,0xa2,0x34,0xff,0xbb,0x3e,0x03,0x44,
			            0x78,0x00,0x90,0xcb,0x88,0x11,0x3a,0x94,
            			0x65,0xc0,0x7c,0x63,0x87,0xf0,0x3c,0xaf,
	            		0xd6,0x25,0xe4,0x8b,0x38,0x0a,0xac,0x72,
		            	0x21,0xd4,0xf8,0x07
                    };

			Array.Copy(logo, 0, cartRom, 4, logo.Length);
			cartRom[0xB2] = 0x96;
			cartRom[0xBD] = 0;
			for (int i = 0xA0; i <= 0xBC; i++) cartRom[0xBD] = (byte)(cartRom[0xBD] - cartRom[i]);
			cartRom[0xBD] = (byte)((cartRom[0xBD] - 0x19) & 0xFF);
			*/
			this.memory.LoadCartridge(cartRom);

			this.Reset();

			if (this.onCpuUpdate != null)
			{
				this.onCpuUpdate(this.arm7, this.memory);
			}
		}

		public void Step()
		{
			//this.Halt();

			this.arm7.Step();

			if (this.onCpuUpdate != null)
			{
				this.onCpuUpdate(this.arm7, this.memory);
			}
		}

		public void StepScanline()
		{
			//this.Halt();

			this.arm7.Execute(960);
			this.videoManager.RenderLine();
			this.videoManager.EnterHBlank(this.arm7);
			this.arm7.Execute(272);
			this.videoManager.LeaveHBlank(this.arm7);

			if (this.onCpuUpdate != null)
			{
				this.onCpuUpdate(this.arm7, this.memory);
			}
		}

		void UpdateInputState()
		{
			ushort ret = 0;
			if (_controller["Up"]) ret |= 64;
			if (_controller["Down"]) ret |= 128;
			if (_controller["Left"]) ret |= 32;
			if (_controller["Right"]) ret |= 16;
			if (_controller["Select"]) ret |= 4;
			if (_controller["Start"]) ret |= 8;
			if (_controller["B"]) ret |= 2;
			if (_controller["A"]) ret |= 1;
			if (_controller["L"]) ret |= 512;
			if (_controller["R"]) ret |= 256;
			ret ^= 0x3ff;
			KeyState = ret;
		}

		private void StepFrame()
		{
			UpdateInputState();
			if (_controller["Power"])
				Reset();

			int vramCycles = 0;
			bool inHblank = false;

			//HighPerformanceTimer profileTimer = new HighPerformanceTimer();

			while (true)
			{


				const int cycleStep = 123;


				if (vramCycles <= 0)
				{
					if (inHblank)
					{
						vramCycles += 960;
						bool HitVBlank = this.videoManager.LeaveHBlank(this.arm7);
						inHblank = false;
						if (HitVBlank)
							break;
					}
					else
					{
						vramCycles += 272;
						this.videoManager.RenderLine();
						this.videoManager.EnterHBlank(this.arm7);
						inHblank = true;
					}
				}

				this.arm7.Execute(cycleStep);
#if ARM_DEBUG
                            if (this.arm7.BreakpointHit)
                            {
                                this.waitingToHalt = true;
                                Monitor.Wait(this);
                            }
#endif
				vramCycles -= cycleStep;
				this.arm7.FireIrq();
			}


		}

		IVideoProvider IEmulator.VideoProvider
		{
			get { return this; }
		}

		ISoundProvider IEmulator.SoundProvider
		{
			get { return null; }
		}

		ISyncSoundProvider IEmulator.SyncSoundProvider
		{
			get { return this; }
		}

		bool IEmulator.StartAsyncSound()
		{
			return false;
		}

		void IEmulator.EndAsyncSound()
		{

		}

		ControllerDefinition IEmulator.ControllerDefinition
		{
			get { return BizHawk.Emulation.Consoles.Nintendo.GBA.GBA.GBAController; }
		}

		IController _controller;

		IController IEmulator.Controller
		{
			get { return _controller; }
			set { _controller = value; }
		}

		void IEmulator.FrameAdvance(bool render, bool rendersound)
		{
			StepFrame();
		}

		int IEmulator.Frame
		{
			get { return 0; }
		}

		int IEmulator.LagCount
		{
			get
			{
				return 0;
			}
			set
			{

			}
		}

		bool IEmulator.IsLagFrame
		{
			get { return false; }
		}

		string IEmulator.SystemId
		{
			get { return "GBA"; }
		}

		bool IEmulator.DeterministicEmulation
		{
			get { return true; }
		}

		byte[] IEmulator.ReadSaveRam()
		{
			return new byte[0];
		}

		void IEmulator.StoreSaveRam(byte[] data)
		{

		}

		void IEmulator.ClearSaveRam()
		{

		}

		bool IEmulator.SaveRamModified
		{
			get
			{
				return false;
			}
			set
			{

			}
		}

		void IEmulator.ResetFrameCounter()
		{

		}

		void IEmulator.SaveStateText(TextWriter writer)
		{

		}

		void IEmulator.LoadStateText(TextReader reader)
		{

		}

		void IEmulator.SaveStateBinary(BinaryWriter writer)
		{

		}

		void IEmulator.LoadStateBinary(BinaryReader reader)
		{

		}

		byte[] IEmulator.SaveStateBinary()
		{
			return new byte[16];
		}

		CoreComm _corecomm;

		CoreComm IEmulator.CoreComm
		{
			get { return _corecomm; }
		}

		IList<MemoryDomain> IEmulator.MemoryDomains
		{
			get { return new List<MemoryDomain>(); }
		}

		MemoryDomain IEmulator.MainMemory
		{
			get { return null; }
		}

		void IDisposable.Dispose()
		{

		}

		int[] vbuf = new int[240 * 160];
		int[] IVideoProvider.GetVideoBuffer() { return vbuf; }
		int IVideoProvider.VirtualWidth { get { return 240; } }
		int IVideoProvider.BufferWidth { get { return 240; } }
		int IVideoProvider.BufferHeight { get { return 160; } }
		int IVideoProvider.BackgroundColor { get { return unchecked((int)0xff000000); } }

		void ISyncSoundProvider.GetSamples(out short[] samples, out int nsamp)
		{
			nsamp = soundManager.SamplesMixed / 2;
			samples = new short[nsamp * 2];
			soundManager.GetSamples(samples, nsamp * 2);
		}

		void ISyncSoundProvider.DiscardSamples()
		{
			// should implement
		}
	}
}