using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Noddybox.Emulation.EightBit.Z80
{
    /// <summary>
    /// Provides an implementation of a Zilog Z80 processor.
    /// </summary>
    public partial class Z80Cpu : ICpu
    {
        #region Private types

        [Flags]
        private enum Z80Flags
        {
            None        = 0x00,
            Carry       = 0x01,
            Neg		    = 0x02,
            PV		    = 0x04,
            Hidden3	    = 0x08,
            HalfCarry   = 0x10,
            Hidden5     = 0x20,
            Zero		= 0x40,
            Sign		= 0x80            
        };

        #endregion

        #region Private data

        // Lookup tables
        //
        private Z80Flags[] PSZtable = new Z80Flags[512];
        private Z80Flags[] SZtable = new Z80Flags[512];
        private Z80Flags[] Ptable = new Z80Flags[512];
        private Z80Flags[] Stable = new Z80Flags[512];
        private Z80Flags[] Ztable = new Z80Flags[512];

        // Machine accessors
        //
        private IMemory memory;
        private IDevice device;
        private Clock   clock;

        // Main registers
        //
        private byte        A;
        private byte        F;
        private byte        R;
        private byte        IFF1;
        private byte        IFF2;
        private IRegister16 BC = Register16Factory.Create();
        private IRegister16 DE = Register16Factory.Create();
        private IRegister16 HL = Register16Factory.Create();
        private IRegister16 IX = Register16Factory.Create();
        private IRegister16 IY = Register16Factory.Create();
        private IRegister16 SP = Register16Factory.Create();
        private IRegister16 PC = Register16Factory.Create();

        // Alternate registers
        //
        private IRegister16 AF_ = Register16Factory.Create();
        private IRegister16 BC_ = Register16Factory.Create();
        private IRegister16 DE_ = Register16Factory.Create();
        private IRegister16 HL_ = Register16Factory.Create();

        #endregion

        #region ICpu Members

        public void Initialise(IMemory memory, IDevice device, Clock clock)
        {
            this.memory = memory;
            this.device = device;
            this.clock = clock;

            Reset();
        }

        public void Reset()
        {
            // TODO: Initial register settings.
        }

        public void Step()
        {
            // TODO: Single step.
        }

        public void Run()
        {
            // TODO: Run for a frame
        }

        public void MaskableInterrupt(byte value)
        {
            // TODO: INT
        }

        public void NonMaskableInterrupt(byte value)
        {
            // TODO: NMI
        }

        #endregion

        #region Constructors

        public Z80Cpu()
        {
            // Setup lookup tables
            //
            for(int f = 0; f < 256; f++)
            {
                Z80Flags p = Z80Flags.None;
                Z80Flags z = Z80Flags.None;
                Z80Flags s = Z80Flags.None;
                int parity = 0;

                for(int b=0; b < 8; b++)
                {
                    if ((f & (1<<b)) == (1<<b))
                    {
                        parity++;
                    }
                }

                if ((parity & 1) == 1)
                {
                    p = Z80Flags.PV;
                }

                if (f == 0)
                {
                    z = Z80Flags.Zero;
                }

                if ((f & 0x80) == 0x80)
                {
                    s = Z80Flags.Sign;
                }

                Ptable[f] = p;
                Stable[f] = s;
                Ztable[f] = z;
                SZtable[f] =z|s;
                PSZtable[f] = z|s|p;

                Ptable[f+256] = Ptable[f]|Z80Flags.Carry;
                Stable[f+256] = Stable[f]|Z80Flags.Carry;
                Ztable[f+256] = Ztable[f]|Z80Flags.Carry;
                SZtable[f+256] = SZtable[f]|Z80Flags.Carry;
                PSZtable[f+256] = PSZtable[f]|Z80Flags.Carry;
            }
        }

        #endregion
    }
}