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;

namespace RomCheater.Docking.MemorySearch
{
    [Serializable]
    public class ResultItemState
    {
        #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

        public ResultItemState()
        {
            this.IconKey = "";
            this.Address = (0).ToString("x8");
            this.Value = (0).ToString("x8");
            this.Frozen = false.ToString();
            this.ValueType = SearchDataTypes._32bits;
            this.IsUnsigned = true;
        }
        public ResultItemState(string address, SearchDataTypes bitsize, bool IsUnsigned, int pid)
            : this(AVPIconKeys.NOTFROZEN, address, "", false.ToString(), bitsize, IsUnsigned)
        {
            uint Address = 0;
            Address = Convert.ToUInt32(this.Address, 16);
            Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
            reader.ReadProcess = Process.GetProcessById(pid);
            if (reader.ReadProcess == null) { logger.Error.WriteLine("Could not attach to process: {0}", pid); return; }
            reader.OpenProcess();
            int bytesReadSize;
            byte[] data;
            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;
            }

            reader.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
            MemoryStream ms = new MemoryStream(data);
            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 address, SearchDataTypes bitsize, bool IsUnsigned)
        //    : this(AVPIconKeys.NOTFROZEN, address, "", false.ToString(), bitsize, IsUnsigned)
        //{
        //    //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(pcsx2_pid, null);
        //    //byte[] buffered_mem = provider.GetMemory();
        //    //MemoryStream ms = new MemoryStream(buffered_mem);
        //    //BinaryReader r_ms = new BinaryReader(ms);
        //    uint Address = 0;
        //    Address = Convert.ToUInt32(this.Address, 16);
        //    //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);
        //    int val = 0;
        //    switch (bitsize)
        //    {
        //        case SearchDataTypes._8bits:
        //            if (IsUnsigned) { this.Value = string.Format("0x{0:x2}", val); }
        //            else { this.Value = string.Format("0x{0:x2}", val); }
        //            break;
        //        case SearchDataTypes._16bits:
        //            if (IsUnsigned) { this.Value = string.Format("0x{0:x4}", val); }
        //            else { this.Value = string.Format("0x{0:x4}", val); }
        //            break;
        //        case SearchDataTypes._32bits:
        //            if (IsUnsigned) { this.Value = string.Format("0x{0:x8}", val); }
        //            else { this.Value = string.Format("0x{0:x8}", val); }
        //            break;
        //        case SearchDataTypes._64bits:
        //            if (IsUnsigned) { this.Value = string.Format("0x{0:x16}", val); }
        //            else { this.Value = string.Format("0x{0:x16}", val); }
        //            break;
        //    }
        //}
        public ResultItemState(string IconKey, string address, string value, string frozen, SearchDataTypes bitsize, bool IsUnsigned)
        {
            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; } }
    }
}