using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RomCheater.Docking.MemorySearch;
using RomCheater.Logging;

namespace RomCheater.Serialization
{
    public interface ISearchResultReader
    {
        void CurrentAddress(out uint Address);
        uint CurrentAddress();
        void CurrentResult<TValue>(out TValue Value);
        TValue CurrentResult<TValue>();

        bool ReadCurrentAddess { get; }
        bool ReadCurrentValue { get; }

    }
    public class SearchResultReader : SerializationReader, ISearchResultReader
    {
        public SearchResultReader() : base() { ReadHeader(); }

        private void ReadHeader()
        {
            try
            {
                //int ResultsRead = 0;
                // SRD (string)
                string magic = Encoding.UTF8.GetString(binReader.ReadBytes(3));
                string SRD = "SRD";
                if (magic != SRD)
                {
                    throw new InvalidOperationException(string.Format("Encountered unexpected magic: {0} expected: {1}", magic, SRD));
                }
                // version (int)
                int version = binReader.ReadInt32();
                if (version != 1)
                {
                    throw new InvalidOperationException(string.Format("Encountered unexpected version: {0} expected: {1}", version, 1));
                }
                // resultcount
                int resultcount = binReader.ReadInt32();
                if (resultcount == 0)
                {
                    throw new InvalidOperationException(string.Format("Result Count is zero"));
                }
                ResultCount = resultcount;
                
                //for (int i = 0; i < ResultCount; i++)
                //{
                //    try
                //    {
                //        ResultsRead = i;
                //        uint address = 0;
                //        // assume uint for data type
                //        uint value = 0;
                //        address = binReader.ReadUInt32();
                //        value = binReader.ReadUInt32();
                //        //if (i % 100000 == 0)
                //        //    logger.VerboseDebug.WriteLine("Result: @0x{0:x8}=0x{1:x8}", address, value);
                //    }
                //    catch (Exception ex)
                //    {
                //        logger.VerboseError.WriteLine("SearchResultReader.ReadHeader():Consistency Check");
                //        //logger.VerboseError.WriteLine(ex.ToString());
                //        logger.VerboseError.WriteLine("Faied entry: {0}", ResultsRead);
                //        break;
                //    }
                //    ResultsRead++; // add 1
                //}
                ////throw new NotImplementedException("DEBUG: testing SearchResultReader consistency");
                //if (ResultCount != ResultsRead)
                //{
                //    throw new InvalidOperationException(string.Format("ResultCount does not match ResultsRead: 0x{0:x8} != 0x{1:x8}", ResultCount, ResultsRead));
                //}  

            }
            catch (System.IO.EndOfStreamException) { }
        }
        #region ISearchResultReader members       
        public bool ReadCurrentAddess { get; private set; }
        public bool ReadCurrentValue { get; private set; }
        public uint CurrentAddress()
        {
            uint Address = 0;
            CurrentAddress(out Address);
            return Address;
        }
        public void CurrentAddress(out uint Address)
        {
            Address = 0;
            try
            {
                if (ReadCurrentAddess && !ReadCurrentValue)
                {
                    throw new InvalidOperationException("Cannot read Current Address because the current Value has not been read. Please call CurrentResult<TValue>() first.");
                }
                Address = binReader.ReadUInt32();
                ReadCurrentAddess = true;
                ReadCurrentValue = false;
            }
            catch (System.IO.EndOfStreamException) { }
        }
        public TValue CurrentResult<TValue>()
        {
            TValue Value = default(TValue);
            CurrentResult<TValue>(out Value);
            return Value;
        }
        public void CurrentResult<TValue>(out TValue Value)
        {
            Value = default(TValue);
            if (!ReadCurrentAddess)
            {
                throw new InvalidOperationException("Cannot read Current Value because the current Address has not been read. Please call CurrentAddress() first.");
            }
            try
            {
                Type t = typeof(TValue);
                switch (t.Name.ToLower())
                {
                    case "byte":
                        Value = (TValue)Convert.ChangeType(binReader.ReadByte(), typeof(TValue));
                        break;
                    case "sbyte":
                        Value = (TValue)Convert.ChangeType(binReader.ReadSByte(), typeof(TValue));
                        break;
                    case "uint16":
                        Value = (TValue)Convert.ChangeType(binReader.ReadUInt16(), typeof(TValue));
                        break;
                    case "int16":
                        Value = (TValue)Convert.ChangeType(binReader.ReadInt16(), typeof(TValue));
                        break;
                    case "uint32":
                        Value = (TValue)Convert.ChangeType(binReader.ReadUInt32(), typeof(TValue));
                        break;
                    case "int32":
                        Value = (TValue)Convert.ChangeType(binReader.ReadInt32(), typeof(TValue));
                        break;
                    case "uint64":
                        Value = (TValue)Convert.ChangeType(binReader.ReadUInt64(), typeof(TValue));
                        break;
                    case "int64":
                        Value = (TValue)Convert.ChangeType(binReader.ReadInt64(), typeof(TValue));
                        break;
                }
                ReadCurrentValue = true;
                ReadCurrentAddess = false;
            }
            catch (System.IO.EndOfStreamException) { }
        }
        #endregion
    }
}