using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Diagnostics;
using RomCheater.Logging;
using Sojaner.MemoryScanner.MemoryProviers;
using RomCheater.PluginFramework.Interfaces;

namespace RomCheater.Docking.MemorySearch
{
    [Serializable]
    public class ResultItemState :
        IAcceptsPlugin<IConfigPlugin>,
        IAcceptsProcess<Process>,
        IAcceptsProcessAndConfig
    {
        #region Implicit Conversion
        public static implicit operator ResultDataType(ResultItemState state)
        {
            ResultDataType _result = null;
            bool frozen = false;
            switch (state.Frozen.ToLower())
            {
                case "true": frozen = true; break;
                case "false": frozen = false; break;
            }

            uint Address = Convert.ToUInt32(state.Address, 16);
            switch (state.ValueType)
            {
                case SearchDataTypes._8bits:
                    if (state.IsUnsigned) { _result = new ResultDataType(Address, frozen, Convert.ToByte(state.Value, 16)); }
                    else { _result = new ResultDataType(Address, frozen, Convert.ToSByte(state.Value)); }
                    break;
                case SearchDataTypes._16bits:
                    if (state.IsUnsigned) { _result = new ResultDataType(Address, frozen, Convert.ToUInt16(state.Value, 16)); }
                    else { _result = new ResultDataType(Address, frozen, Convert.ToInt16(state.Value, 16)); }
                    break;
                case SearchDataTypes._32bits:
                    if (state.IsUnsigned) { _result = new ResultDataType(Address, frozen, Convert.ToUInt32(state.Value, 16)); }
                    else { _result = new ResultDataType(Address, frozen, Convert.ToInt32(state.Value, 16)); }
                    break;
                case SearchDataTypes._64bits:
                    if (state.IsUnsigned) { _result = new ResultDataType(Address, frozen, Convert.ToUInt64(state.Value, 16)); }
                    else { _result = new ResultDataType(Address, frozen, Convert.ToInt64(state.Value, 16)); }
                    break;
            }
            return _result;
        }
        #endregion
        #region  IAcceptsProcess<Process> Members
        public Process AcceptedProcess { get; set; }
        #endregion
        #region IAcceptsPlugin<IConfigPlugin> Members
        public IConfigPlugin AcceptedPlugin { get; set; }
        #endregion
        public ResultItemState() : this(null) { }
        public ResultItemState(IAcceptsProcessAndConfig pconfig)
        {
            this.IconKey = "";
            this.Address = (0).ToString("x8");
            this.Value = (0).ToString("x8");
            this.Frozen = false.ToString();
            this.ValueType = SearchDataTypes._32bits;
            this.IsUnsigned = true;

            this.AcceptedPlugin = pconfig.AcceptedPlugin;
            this.AcceptedProcess = pconfig.AcceptedProcess;
        }
        public ResultItemState(string address, SearchDataTypes bitsize, bool IsUnsigned, IAcceptsProcessAndConfig pconfig)
            : this(AVPIconKeys.NOTFROZEN, address, "", false.ToString(), bitsize, IsUnsigned, pconfig)
        {
            int Address = 0;
            Address = Convert.ToInt32(this.Address, 16);           
            int bytesReadSize;
            uint bytesToRead = 0;
            switch (bitsize)
            {
                case SearchDataTypes._8bits:
                    bytesToRead = 1;
                    break;
                case SearchDataTypes._16bits:
                    bytesToRead = 2;
                    break;
                case SearchDataTypes._32bits:
                    bytesToRead = 4;
                    break;
                case SearchDataTypes._64bits:
                    bytesToRead = 8;
                    break;
            }
            byte[] data = new byte[bytesToRead];
            using (GenericMemoryProvider provider = new GenericMemoryProvider(pconfig))
            {
                provider.OpenProvider();
                provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
                //provider.CloseProvider();
            }
            using (MemoryStream ms = new MemoryStream(data))
            {
                using (BinaryReader r_ms = new BinaryReader(ms))
                {

                    //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);
                    //int val = 0;
                    switch (bitsize)
                    {
                        case SearchDataTypes._8bits:
                            if (IsUnsigned) { this.Value = string.Format("0x{0:x2}", r_ms.ReadByte()); }
                            else { this.Value = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
                            break;
                        case SearchDataTypes._16bits:
                            if (IsUnsigned) { this.Value = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
                            else { this.Value = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
                            break;
                        case SearchDataTypes._32bits:
                            if (IsUnsigned) { this.Value = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
                            else { this.Value = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
                            break;
                        case SearchDataTypes._64bits:
                            if (IsUnsigned) { this.Value = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
                            else { this.Value = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
                            break;
                    }
                }
            }
        }
        public ResultItemState(string IconKey, string address, string value, string frozen, SearchDataTypes bitsize, bool IsUnsigned, IAcceptsProcessAndConfig pconfig)
            : this(pconfig)
        {
            this.IconKey = IconKey;
            this.Address = address;
            this.Value = value;
            this.Frozen = frozen;
            this.ValueType = bitsize;
            this.IsUnsigned = IsUnsigned;
        }


        private string _IconKey;
        private string _Address;
        private string _Value;
        private string _Frozen;

        public string IconKey { get { return _IconKey; } set { _IconKey = value; } }
        public string Address { get { return _Address; } set { _Address = value; } }
        public string Value { get { return _Value; } set { _Value = value; } }
        public string Frozen { get { return _Frozen; } set { _Frozen = value; } }


        private bool _IsUnsigned;
        public bool IsUnsigned { get { return _IsUnsigned; } set { _IsUnsigned = value; } }
        private SearchDataTypes _ValueType;
        public SearchDataTypes ValueType { get { return _ValueType; } set { _ValueType = value; } }
    }
}