using System;
using System.Collections.Generic;
using System.Globalization;

namespace EVMKurs
{
    class Program
    {
        #region vars
        /// <summary>
        /// Аккумулятор
        /// </summary>
        readonly static Register Akk = new Register(16);
        /// <summary>
        /// Регистр команд
        /// </summary>
        readonly static Register CommandReg = new Register(16);
        /// <summary>
        /// Память
        /// </summary>
        readonly static MemoryCell[] Memory = new MemoryCell[1024];
        #endregion

        #region Anl
        /// <summary>
        /// Метод - эмулятор команды ANL
        /// </summary>
        /// <param name="a">Регистр назначения</param>
        /// <param name="b">Регистр - участник операции</param>
        /// <param name="isRef">Флаг косвенной адресации</param>
        private static void Anl(Register a, Register b, bool isRef = false)
        {
            Anl(a, !isRef ? b.Value : Memory[b.Value].Value);
        }
        /// <summary>
        /// Метод - эмулятор команды ANL
        /// </summary>
        /// <param name="a">Регистр назначения</param>
        /// <param name="b">Значение-участник или значение-адрес(в зависимости от isRef)</param>
        /// <param name="isRef">Флаг является ли адресация косвенной</param>
        private static void Anl(Register a, Int16 b, bool isRef = false)
        {
            if (!isRef)
            {
                a.Value = (Int16)(a.Value & b);
            }
            else
            {
                a.Value = (Int16)(a.Value & Memory[b].Value);
            }
        }

        #endregion

        #region JZ

        /// <summary>
        /// Метод - эмулятор команды JZ
        /// </summary>
        /// <param name="a">Адрес перехода</param>
        private static void Jz(Int16 a)
        {
            if (Akk.Value == 0)
                CommandReg.Value = a;
        }

        #endregion

        #region DEC
        /// <summary>
        /// Метод-эмулятор команды DEC
        /// </summary>
        /// <param name="a">Регистр-участник</param>
        /// <param name="isRef">Флаг косвенной адресации</param>
        private static void Dec(Register a, bool isRef = false)
        {
            if (!isRef)
            {
                a--;
            }
            else
            {
                Dec(a.Value);
            }
        }
        /// <summary>
        /// Метод-эмулятор команды DEC
        /// </summary>
        /// <param name="a">Адрес ячейки-участницы</param>
        private static void Dec(Int16 a)
        {
            Memory[a]--;
        }

        #endregion

        #region MOV

        /// <summary>
        /// Метод - эмулятор команды Mov
        /// </summary>
        /// <param name="a">Регистр назначения</param>
        /// <param name="b">Регистр - участник операции</param>
        /// <param name="isARef">Флаг косвенной адресации регистра а</param>
        /// <param name="isBRef">Флаг косвенной адресации регистра b</param>
        private static void Mov(Register a, Register b, bool isARef = false, bool isBRef = false)
        {
            if (!isARef)
            {
                a.Value = !isBRef ? b.Value : Memory[b.Value].Value;
                return;
            }
            Memory[a.Value].Value = !isBRef ? b.Value : Memory[b.Value].Value;
        }

        /// <summary>
        /// Метод - эмулятор команды Mov
        /// </summary>
        /// <param name="a">Регистр назначения</param>
        /// <param name="b">Константа - адрес, или константа-значение (в зависимости от isBRef)</param>
        /// <param name="isARef">Флаг косвенной адресации регистра а</param>
        /// <param name="isBRef">Флаг косвенной адресации b</param>
        private static void Mov(Register a, Int16 b, bool isARef = false, bool isBRef = false)
        {
            if (!isARef)
            {
                a.Value = !isBRef ? b : Memory[b].Value;
                return;
            }
            Memory[a.Value].Value = !isBRef ? b : Memory[b].Value;
        }

        #endregion


        static void Main(string[] args)
        {
            Console.WriteLine("*** Test MOV(akk, reg) ***");
            Register reg = new Register(16,5);
            Akk.Value = 0;
            Console.WriteLine("Akk = " + Akk.Value);
            Console.WriteLine("Reg = " + reg.Value);
            Console.WriteLine("Execute MOV");
            Mov(Akk, reg);
            Console.WriteLine("Akk = " + Akk.Value);

            Console.WriteLine();

            Console.WriteLine("*** Test MOV(akk, @Reg) ***");
            Memory[40] = new MemoryCell(16, 0);
            Console.WriteLine("Memory[40] = " + Memory[40].Value);
            reg.Value = 40;
            Console.WriteLine("Reg = " + reg.Value);
            Console.WriteLine("Execute MOV");
            Mov(reg, Akk, true);
            Console.WriteLine("Memory[40] = " + Memory[40].Value);

            Console.WriteLine();

            Console.WriteLine("*** Test negative value ***");
            Akk.Value = -10;
            Console.WriteLine("Akk(10) = " + Akk.Value);
            Console.WriteLine("Akk(2) = " +Akk.GetValueWithCounting(2));

            Console.WriteLine();

            Console.WriteLine("*** Test DEC(reg) ***");
            Akk.Value = 2;
            Console.WriteLine("Akk = " + Akk.Value);
            Console.WriteLine("Execute DEC");
            Dec(Akk);
            Console.WriteLine("Akk = " + Akk.Value);

            Console.WriteLine();

            Console.WriteLine("*** Test DEC(reg) reg = 0 ***");
            Akk.Value = 0;
            Console.WriteLine("Akk = " + Akk.Value);
            Console.WriteLine("Execute DEC");
            Dec(Akk);
            Console.WriteLine("Akk(16) = " + Akk.GetValueWithCounting(16));

            Console.WriteLine();

            Console.WriteLine("*** Test DEC(@Reg) ***");
            Memory[1] = new MemoryCell(16, 10);
            Console.WriteLine("Memory[1] = " + Memory[1].Value);
            Akk.Value = 1;
            Console.WriteLine("Akk = " + Akk.Value);
            Console.WriteLine("Execute DEC");
            Dec(Akk, true);
            Console.WriteLine("Memory[1] = " + Memory[1].Value);

            Console.WriteLine();

            Console.WriteLine("*** Test DEC(Memory[i]) ***");
            Console.WriteLine("Execute DEC");
            Dec(1);
            Console.WriteLine("Memory[1] = " + Memory[1].Value);

            Console.WriteLine();

            Console.WriteLine("*** Test JZ(15) ***");
            Akk.Value = 0;
            Console.WriteLine("Akk = " + Akk.Value);
            Console.WriteLine("CommandReg = " + CommandReg.Value);
            Console.WriteLine("Execute JZ");
            Jz(15);
            Console.WriteLine("CommandReg = " + CommandReg.Value);

            Console.WriteLine();

            Console.WriteLine("*** Test ANL(reg, @reg) ***");
            Memory[60] = new MemoryCell(16, 9);
            Console.WriteLine("Memory[60] = " + Memory[60].GetValueWithCounting(2));
            Akk.Value = 5;
            Console.WriteLine("Akk = " + Akk.GetValueWithCounting(2));
            reg.Value = 60;
            Console.WriteLine("Reg = " + reg.Value);
            Console.WriteLine("Execute ANL");
            Anl(Akk,reg, true);
            Console.WriteLine("Akk = " + Akk.GetValueWithCounting(2));

            Console.ReadLine();
        }

    }

    /// <summary>
    /// Класс, представляющий ячейку памяти
    /// </summary>
    internal class MemoryCell
    {
        public static MemoryCell operator --(MemoryCell a)
        {
            if (a.Value == 0)
                a.Value = Int16.Parse(new string('f', (a.Capacity - 1) / 4), NumberStyles.AllowHexSpecifier);
            else
                a.Value--;
            return a;
        }

        private Int16 _value;
        /// <summary>
        /// Текущее значение регистра
        /// </summary>
        public Int16 Value
        {
            get { return _value; }

            set
            {
                if (Convert.ToString(value, 2).Length > Capacity)
                    throw new Exception("Разрядность регистра меньше устанавливаемого занчения");
                _value = value;
            }
        }

        /// <summary>
        /// Строковое представление значения регистра в соответствии с системой исчисления
        /// </summary>
        /// <param name="counting">Основание системы исчисления</param>
        /// <returns>Строковое представление значения регистра в соответствии с системой исчисления</returns>
        public string GetValueWithCounting(Int16 counting)
        {
            var tempResult = Convert.ToString(Value, counting);
            var charCounter = Capacity / (Int16)Math.Log(counting, 2);
            return tempResult.Length < charCounter
                ? string.Format("{0}{1}", new String('0', charCounter - tempResult.Length), tempResult)
                : tempResult.Substring(tempResult.Length - charCounter);
        }

        /// <summary>
        /// Разрядность регистра
        /// </summary>
        public byte Capacity { get; set; }

        /// <summary>
        /// Конструктор класса Register
        /// </summary>
        /// <param name="capacity">Разрядность регистра(до 32)</param>
        public MemoryCell(byte capacity)
        {
            if (capacity > 32)
                throw new ArgumentOutOfRangeException("capacity");
            Capacity = capacity;
            _value = 0;
        }

        public MemoryCell(byte capacity, Int16 value)
            : this(capacity)
        {
            Value = value;
        }
    }

    /// <summary>
    /// Класс, представляющий регистр
    /// </summary>
    internal class Register : MemoryCell
    {
        public Register(byte capacity)
            : base(capacity)
        {
        }

        public Register(byte capacity, Int16 value)
            : this(capacity)
        {
            Value = value;
        }

        public static Register operator --(Register a)
        {
            if (a.Value == 0)
                a.Value = Int16.Parse(new string('f', (a.Capacity - 1) / 4), NumberStyles.AllowHexSpecifier);
            else
                a.Value--;
            return a;
        }
    }
    }