using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Utilities.TransparentControls.ListView;
using System.IO;
using RomCheater.Logging;
using RomCheater.Docking.MemorySearch;
using Sojaner.MemoryScanner.MemoryProviers;
using System.Diagnostics;
using RomCheater.PluginFramework.Interfaces;

namespace System.Windows.Forms
{
    [Serializable]
    public partial class AddressValuePairList : 
        dbufferedListView, IAvpExport, IAvpImport, IAvpLvSupport, IAvpLvColumnSupport, IAvpFreeze,
        IAcceptsProcess<Process>,
        IAcceptsPlugin<IConfigPlugin>
    {
        #region IAcceptsProcess<Process> Members
        public Process AcceptedProcess { get; set; }
        #endregion
        #region IAcceptsPlugin<IConfigPlugin> Members
        public IConfigPlugin AcceptedPlugin { get; set; }
        #endregion

        public class AddressValuePairListSorter : System.Collections.IComparer
        {

            public int Compare(object o1, object o2)
            {
                if (!(o1 is ListViewItem))
                    return (0);
                if (!(o2 is ListViewItem))
                    return (0);
                ListViewItem lvi1 = (ListViewItem)o1;
                ListViewItem lvi2 = (ListViewItem)o2;
                int result = 0;
                if (ByColumn > 0)
                {
                    string str1 = lvi1.SubItems[ByColumn].Text;
                    string str2 = lvi2.SubItems[ByColumn].Text;
                    if (lvi1.ListView.Sorting == SortOrder.Ascending)
                        result = String.Compare(str1, str2);
                    else
                        result = String.Compare(str2, str1);
                }
                else
                {
                    if (lvi1.ListView.Sorting == SortOrder.Ascending)
                        result = String.Compare(lvi1.ImageKey, lvi2.ImageKey);
                    else
                        result = String.Compare(lvi2.ImageKey, lvi1.ImageKey);
                }

                //LastSort = ByColumn;

                return (result);
            }
            public int ByColumn
            {
                get { return Column; }
                set { Column = value; }
            }
            int Column = 0;

            //public int LastSort
            //{
            //    get { return LastColumn; }
            //    set { LastColumn = value; }
            //}
            //int LastColumn = 0;
        }

        private delegate ListViewItem ThreadSafe_GetResultItem(int index);
        private ResultItem GetResultItem(int index)
        {
            AddressValuePairList lv = this;
            ResultItem item = (ResultItem)lv.Items[index].Clone();
            return item;
        }

        private ImageList icon_list;

        int UKNOWN_COLUMN_COUNT = 0;

        private string ColumnTextChecker(string ColumnName)
        {
            string _column_text = ColumnName;
            if (_column_text == new AVPColumnText(AVPColumnType.UKNOWN).ColumnText)
            {
                _column_text = string.Format("{0} {1:00}", ColumnName, UKNOWN_COLUMN_COUNT);
                UKNOWN_COLUMN_COUNT++;
                return _column_text;
            }
            else
            {
                return _column_text;
            }
        }

        public AddressValuePairList()
            : base()
        {
            InitializeComponent();

            icon_list = new ImageList();
            icon_list.Images.Add(AVPIconKeys.FROZEN, RomCheater.Properties.Resources.freeze);
            icon_list.Images.Add(AVPIconKeys.NOTFROZEN, RomCheater.Properties.Resources.notfreeze);

            this.SmallImageList = icon_list;
            this.LargeImageList = icon_list;
            this.FullRowSelect = true;
            this.AllowColumnReorder = true;

            this.HideSelection = false;
            this.MultiSelect = true;

            _Items = new ResultItemCollection(this);
            AVPColumnText col_text = new AVPColumnText();
            // Icon
            col_text = new AVPColumnText(AVPColumnType.ICON);
            this.Columns.Add(col_text.ColumnKey, ColumnTextChecker(col_text.ColumnText), col_text.ColumnWidth);
            // Address
            col_text = new AVPColumnText(AVPColumnType.ADDRESS);
            this.Columns.Add(col_text.ColumnKey, ColumnTextChecker(col_text.ColumnText), col_text.ColumnWidth);
            // Value
            col_text = new AVPColumnText(AVPColumnType.VALUE);
            this.Columns.Add(col_text.ColumnKey, ColumnTextChecker(col_text.ColumnText), col_text.ColumnWidth);
            // Is Frozen
            col_text = new AVPColumnText(AVPColumnType.FROZEN);
            this.Columns.Add(col_text.ColumnKey, ColumnTextChecker(col_text.ColumnText), col_text.ColumnWidth);
#if HAVE_LISTVIEW_FREEZE_BUTTON
            // Freeze button
            col_text = new AVPColumnText(AVPColumnType.FREEZE_BUTTON);
            this.Columns.Add(col_text.ColumnKey, ColumnTextChecker(col_text.ColumnText), col_text.ColumnWidth);
#endif
#if USE_FAKE_LV_ITEM
            uint address = 0x200;
            byte value = 0x10;
            bool frozen = true;
            ResultItem item = new ResultItem(address, frozen, value);
            ResultDataType result = (ResultDataType)item.Tag;
            //// if USE_FAKE_LV_ITEM is defined these will assert that everything is correct
            //// Debug Assert: Address
            //Debug.Assert(result.Address == address, string.Format("Address: 0x{0:x8} != 0x{1:x8}", result.Address, address));
            //// Debug Assert: Value
            //Debug.Assert((short)result.Value == value, string.Format("Value: 0x{0:x16} != 0x{1:x16}", result.Value, (object)value));
            //// Debug Assert: IsFrozen
            //Debug.Assert(result.IsFrozen == frozen, string.Format("Frozen: {0} != {1}", result.IsFrozen, frozen));
            this.Items.Add(item);
#endif

            this.ColumnClick += new ColumnClickEventHandler(AddressValuePairList_ColumnClick);

            this.AcceptedPlugin = null;
            this.AcceptedProcess = null;

        }

        void AddressValuePairList_ColumnClick(object sender, ColumnClickEventArgs e)
        {
            AddressValuePairListSorter sorter = new AddressValuePairListSorter();
            this.ListViewItemSorter = sorter;
            if (!(this.ListViewItemSorter is AddressValuePairListSorter))
                return;
            sorter = (AddressValuePairListSorter)this.ListViewItemSorter;
            //if (sorter.LastSort == e.Column)
            //{
            //    if (this.Sorting == SortOrder.Ascending)
            //        this.Sorting = SortOrder.Descending;
            //    else
            //        this.Sorting = SortOrder.Ascending;
            //}
            //else
            //{
            //    this.Sorting = SortOrder.Descending;
            //}
            if (this.Sorting == SortOrder.Ascending)
            {
                this.Sorting = SortOrder.Descending;
            }
            else
            {
                this.Sorting = SortOrder.Ascending;
            }
            sorter.ByColumn = e.Column;

            this.Sort();
        }

        private string WriteResultItem(ResultItem item)
        {
            ResultDataType _result = (ResultDataType)item.Tag;

            return string.Format("{0},{1},{2},{3},{4}",
                item.SubItems[GetColumnByType(AVPColumnType.ADDRESS)].Text,
                item.SubItems[GetColumnByType(AVPColumnType.VALUE)].Text,
                item.SubItems[GetColumnByType(AVPColumnType.FROZEN)].Text,
                _result.ValueType,
                _result.IsUnsigned);
        }

        #region IAvpExport Members
        public bool ExportToClipboard()
        {
            if (!(this.Items.Count > 0)) return false;
            try
            {
                StringBuilder builder = new StringBuilder();
                foreach (ResultItem item in this.Items)
                {
                    builder.Append(this.WriteResultItem(item));
                    builder.AppendLine();
                }
                Clipboard.SetText(builder.ToString());
                return true;
            }
            catch { return false; }
        }
        public bool ExportToFile(string filename)
        {
            if (!(this.Items.Count > 0)) return false;

            FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write);
            StreamWriter sw = new StreamWriter(fs);
            foreach (ResultItem item in this.Items)
            {
                sw.Write(this.WriteResultItem(item));
                sw.WriteLine();
            }
            sw.Flush();
            sw.Close();

            return true;
        }
        public bool ExportToFile()
        {
            DialogResult result = ResultsSaver.ShowDialog();
            if (result != DialogResult.OK) return false;
            string filename = ResultsSaver.FileName;
            return this.ExportToFile(filename);
        }
        #endregion
        #region IAvpImport Members
        public bool ImportFromClipboard()
        {
            try
            {
                string clipboard_data = (string)Clipboard.GetData(System.Windows.Forms.DataFormats.Text);

                MemoryStream ms = new MemoryStream(ASCIIEncoding.ASCII.GetBytes(clipboard_data));
                StreamReader sr = new StreamReader(ms);
                this.Items.Clear();
                List<ResultItem> patch_item_list = new List<ResultItem>();

                while (!sr.EndOfStream)
                {
                    string line = sr.ReadLine();
                    string[] tokenized_line = line.Split(',');
                    string Address = tokenized_line[0];
                    string Value = tokenized_line[1];
                    string Frozen = tokenized_line[2];

                    string _data_type = tokenized_line[3];
                    string IsUnsigned = tokenized_line[4];
                    bool _IsUnsigned = false;
                    switch (IsUnsigned.ToLower())
                    {
                        case "true": _IsUnsigned = true; break;
                        case "false": _IsUnsigned = false; break;
                    }
                    int BIT_SIZE = -1;

                    foreach (int val in Enum.GetValues(typeof(SearchDataTypes)))
                    {
                        if (Enum.GetName(typeof(SearchDataTypes), val) == _data_type)
                        {
                            BIT_SIZE = val;
                            break;
                        }
                    }

                    ResultItem item = new ResultItem(Address, Value, Frozen, (SearchDataTypes)BIT_SIZE, _IsUnsigned);
                    patch_item_list.Add(item);
                }
                this.Items.AddRange(patch_item_list.ToArray());
                sr.Close();
                return true;
            }
            catch { return false; }

        }
        public bool ImportFromFile(string filename)
        {
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
            StreamReader sr = new StreamReader(fs);

            this.Items.Clear();
            List<ResultItem> patch_item_list = new List<ResultItem>();

            while (!sr.EndOfStream)
            {
                string line = sr.ReadLine();
                string[] tokenized_line = line.Split(',');
                string Address = tokenized_line[0];
                string Value = tokenized_line[1];
                string Frozen = tokenized_line[2];

                string _data_type = tokenized_line[3];
                string IsUnsigned = tokenized_line[4];
                bool _IsUnsigned = false;
                switch (IsUnsigned.ToLower())
                {
                    case "true": _IsUnsigned = true; break;
                    case "false": _IsUnsigned = false; break;
                }
                int BIT_SIZE = -1;

                foreach (int val in Enum.GetValues(typeof(SearchDataTypes)))
                {
                    if (Enum.GetName(typeof(SearchDataTypes), val) == _data_type)
                    {
                        BIT_SIZE = val;
                        break;
                    }
                }

                ResultItem item = new ResultItem(Address, Value, Frozen, (SearchDataTypes)BIT_SIZE, _IsUnsigned);
                patch_item_list.Add(item);
            }
            this.Items.AddRange(patch_item_list.ToArray());
            sr.Close();
            return true;
        }
        public bool ImportFromFile()
        {
            DialogResult result = ResultsLoader.ShowDialog();
            if (result != DialogResult.OK) return false;
            string filename = ResultsLoader.FileName;
            return this.ImportFromFile(filename);
        }
        #endregion
        #region IAvpLvSupport Members
        private bool DONOT_USE_DETAILS_VIEW_BY_DEFAULT = false;
        public bool OverrideDetailsViewByDefault { get { return DONOT_USE_DETAILS_VIEW_BY_DEFAULT; } set { DONOT_USE_DETAILS_VIEW_BY_DEFAULT = value; } }
        public new System.Windows.Forms.View View { get { return base.View; } set { if (this.OverrideDetailsViewByDefault) { base.View = value; } else { base.View = View.Details; } } }
        public new ListView.ColumnHeaderCollection Columns
        {
            get
            {
                return base.Columns;
            }
        }
        private ResultItemCollection _Items;
        public new ResultItemCollection Items
        {
            get
            {
                return _Items;
            }
        }
        #endregion
        #region IAvpLvColumnSupport Members
        public int GetColumnByType(AVPColumnType AVPColType)
        {
            return GetColumnByKey(Enum.GetName(typeof(AVPColumnType), AVPColType));
        }
        public int GetColumnByKey(string AVPColType)
        {
            List<string> avp_cols = new List<string>();

            foreach (int val in Enum.GetValues(typeof(AVPColumnType)))
            {
                avp_cols.Add(Enum.GetName(typeof(AVPColumnType), val));
            }

            int index = -1;
            bool foundColumn = false;
            foreach (string col in avp_cols)
            {
                if (AVPColType == col)
                {
                    foundColumn = true;
                    break;
                }
            }
            if (!foundColumn)
            {
                index = -1;
            }
            else
            {
                index = this.Columns[AVPColType].Index;
            }

            return index;
        }
        #endregion
        #region IAvpFreeze Members
        private List<int> FrozenIndexes = new List<int>();
        public bool ItemIsFrozen(int index)
        {
            return FrozenIndexes.Contains(index) && (this.Items[index].Tag as ResultDataType).IsFrozen;
        }
        public void FreezeItem(int index)
        {
            if (!(this.ItemIsFrozen(index)))
            {
                FrozenIndexes.Add(index);
                this.Items[index].ImageKey = AVPIconKeys.FROZEN;
                this.Items[index].SubItems[new AVPColumnText(AVPColumnType.FROZEN).ColumnIndex].Text = true.ToString();
                ResultDataType tmp_result = (ResultDataType)this.Items[index].Tag;

                string Address = this.Items[index].SubItems[new AVPColumnText(AVPColumnType.ADDRESS).ColumnIndex].Text;
                string Frozen = this.Items[index].SubItems[new AVPColumnText(AVPColumnType.FROZEN).ColumnIndex].Text;
                object Value = Convert.ToUInt64(this.Items[index].SubItems[new AVPColumnText(AVPColumnType.FROZEN).ColumnIndex].Text, 16);

                SearchDataTypes ValueType = tmp_result.ValueType;

                ResultDataType result = new ResultDataType(Convert.ToUInt32(Address, 16), Convert.ToBoolean(Frozen), Value, ValueType);
                result.IsFrozen = true;
                this.Items[index].Tag = result;
                ResultItem temp = (ResultItem)this.Items[index];
                this.Items[index].Remove();
                this.Items.Insert(index, temp);
                this.Refresh();
                this.Update();
            }
        }
        public void ThawItem(int index)
        {
            if (this.ItemIsFrozen(index))
            {
                FrozenIndexes.Remove(index);
                this.Items[index].ImageKey = AVPIconKeys.NOTFROZEN;
                this.Items[index].SubItems[new AVPColumnText(AVPColumnType.FROZEN).ColumnIndex].Text = false.ToString();
                ResultDataType result = (ResultDataType)this.Items[index].Tag;
                result.IsFrozen = false;
                this.Items[index].Tag = result;
                ResultItem temp = (ResultItem)this.Items[index];
                this.Items[index].Remove();
                this.Items.Insert(index, temp);
                this.Refresh();
                this.Update();
            }
        }
        private int _ProcessID;
        public int ProcessID { get { return _ProcessID; } set { _ProcessID = value; } }
        #endregion

        private void freezer_Tick(object sender, EventArgs e)
        {
            if (!(FrozenIndexes.Count > 0)) return;
            if (!(patcherwriter.IsBusy))
                patcherwriter.RunWorkerAsync();
        }

        private void patcherwriter_DoWork(object sender, DoWorkEventArgs e)
        {
            for (int i = 0; i < FrozenIndexes.Count; i++)
            {
                if (patcherwriter.CancellationPending)
                {
                    e.Cancel = true;
                    return;
                }
                int index = FrozenIndexes[i];
                ResultItem iter = null;
                if (this.InvokeRequired)
                {
                    ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
                    object item = this.Invoke(_get_item, new object[] { index });
                    if (item != null)
                        iter = (ResultItem)item;
                }
                else
                {
                    iter = (ResultItem)this.Items[index];
                }
                using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                {
                    provider.OpenProvider();
                    ResultDataType result = (ResultDataType)iter.Tag;
                    uint Address = result.Address;
                    byte[] bitData = new byte[] { };
                    switch (result.ValueType)
                    {
                        case SearchDataTypes._8bits:
                            if (result.IsUnsigned) { provider.PatchMemory(Address, Convert.ToByte(result.Value)); }
                            else { provider.PatchMemory(Address, Convert.ToSByte(result.Value)); }
                            break;
                        case SearchDataTypes._16bits:
                            if (result.IsUnsigned) { provider.PatchMemory(Address, Convert.ToUInt16(result.Value)); }
                            else { provider.PatchMemory(Address, Convert.ToInt16(result.Value)); }
                            break;
                        case SearchDataTypes._32bits:
                            if (result.IsUnsigned) { provider.PatchMemory(Address, Convert.ToUInt32(result.Value)); }
                            else { provider.PatchMemory(Address, Convert.ToInt32(result.Value)); }
                            break;
                        case SearchDataTypes._64bits:
                            if (result.IsUnsigned) { provider.PatchMemory(Address, Convert.ToUInt64(result.Value)); }
                            else { provider.PatchMemory(Address, Convert.ToInt64(result.Value)); }
                            break;
                    }
                    result = null;
                    provider.CloseProvider();
                }
            }
        }

        private void patcherwriter_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (FrozenIndexes.Count > 0) // only run if we have frozen patches
                patcherwriter.RunWorkerAsync(); // restart the freeze operation
        }
    }

    public enum AVPColumnType
    {
        ICON,
        ADDRESS,
        VALUE,
        FROZEN,
#if HAVE_LISTVIEW_FREEZE_BUTTON
        FREEZE_BUTTON,
#endif
        UKNOWN = 0x6000
    }

    #region ResultItem

#if HAVE_LISTVIEW_FREEZE_BUTTON
    public class ListviewSubItemButton : ListViewItem.ListViewSubItem
    {
    }
    public class ListViewFreezeToggle : ListviewSubItemButton
    {
        public ListViewFreezeToggle() : this(false) { }
        public ListViewFreezeToggle(bool frozen) { this.ToggleText(frozen); }

        public void ToggleText(bool frozen)
        {
            _Frozen = frozen;
            if (frozen) { this.Text = "UnFreeze"; }
            else { this.Text = "Freeze"; }
        }
        public ListViewFreezeToggle Toggle(bool frozen)
        {
            _Frozen = frozen;
            if (frozen) { this.Text = "UnFreeze"; }
            else { this.Text = "Freeze"; }

            return this;
        }
        private bool _Frozen;
        public bool Frozen
        {
            get { return _Frozen; }
        }

    }
#endif

    public class ResultItem : ListViewItem
    {
#if HAVE_LISTVIEW_FREEZE_BUTTON
        private ListViewFreezeToggle btnFreezeToggle;
#endif

        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append("{");
            builder.AppendFormat("{0},{1},{2}",
                this.SubItems[new AVPColumnText(AVPColumnType.ADDRESS).ColumnIndex].Text,
                this.SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text,
                this.SubItems[new AVPColumnText(AVPColumnType.FROZEN).ColumnIndex].Text);
            builder.Append(" {");
            builder.AppendFormat("tag:{0}", (this.Tag as ResultDataType).ToString());
            builder.Append("} ");
            builder.Append("}");
            return builder.ToString();
        }

        public ResultItem()
            : base()
        {
        }
        private void initialize() { this.initialize(false); }
        private void initialize(bool frozen)
        {
#if HAVE_LISTVIEW_FREEZE_BUTTON
            btnFreezeToggle = new ListViewFreezeToggle();
            btnFreezeToggle.Name = "btnFreezeToggle";
            //btnFreezeToggle.Click += new EventHandler(btnFreezeToggle_Click);         
#endif
            this.Text = "";
            if (frozen)
            {
                this.ImageKey = AVPIconKeys.FROZEN;
                _isFrozen = true;
            }
            else
            {
                this.ImageKey = AVPIconKeys.NOTFROZEN;
                _isFrozen = false;
            }
        }

        private bool _isFrozen = false;
        public bool ItemIsFrozen()
        {
            return _isFrozen;
        }

        public void FreezeItem()
        {
            this.ImageKey = AVPIconKeys.FROZEN;
            _isFrozen = true;
        }
        public void ThawItem()
        {
            this.ImageKey = AVPIconKeys.NOTFROZEN;
            _isFrozen = false;
        }

        //void btnFreezeToggle_Click(object sender, EventArgs e)
        //{
        //    throw new NotImplementedException();
        //}
        public ResultItem(string address)
            : base()
        {
            this.initialize();
            this.SubItems.Add(address);
        }
        public ResultItem(string address, string value, string frozen, SearchDataTypes bit_size, bool unsigned)
            : base()
        {
            bool _frozen = false;
            if (frozen.ToLower() == "true") _frozen = true;
            this.initialize(_frozen);
            this.SubItems.Add(address);
            this.SubItems.Add(value);
            this.SubItems.Add(frozen);
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = null;

            switch (bit_size)
            {
                case SearchDataTypes._8bits:
                    if (unsigned) { resulttype = new ResultDataType(Convert.ToUInt32(address, 16), _frozen, Convert.ToByte(value, 16)); }
                    else { resulttype = new ResultDataType(Convert.ToUInt32(address, 16), _frozen, Convert.ToByte(value, 16)); }
                    break;
                case SearchDataTypes._16bits:
                    if (unsigned) { resulttype = new ResultDataType(Convert.ToUInt32(address, 16), _frozen, Convert.ToUInt16(value, 16)); }
                    else { resulttype = new ResultDataType(Convert.ToUInt32(address, 16), _frozen, Convert.ToInt16(value, 16)); }
                    break;
                case SearchDataTypes._32bits:
                    if (unsigned) { resulttype = new ResultDataType(Convert.ToUInt32(address, 16), _frozen, Convert.ToUInt32(value, 16)); }
                    else { resulttype = new ResultDataType(Convert.ToUInt32(address, 16), _frozen, Convert.ToInt32(value, 16)); }
                    break;
                case SearchDataTypes._64bits:
                    if (unsigned) { resulttype = new ResultDataType(Convert.ToUInt32(address, 16), _frozen, Convert.ToUInt64(value, 16)); }
                    else { resulttype = new ResultDataType(Convert.ToUInt32(address, 16), _frozen, Convert.ToInt64(value, 16)); }
                    break;

            }
            this.Tag = resulttype;
        }
        public ResultItem(uint address)
            : base()
        {
            this.initialize();
            this.SubItems.Add(string.Format("0x{0:x8}", address));
        }
        public ResultItem(uint address, bool frozen)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
        }
        public ResultItem(uint address, bool frozen, byte value)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
            this.SubItems.Add(string.Format("0x{0:x2}", value));
            this.SubItems.Add(frozen.ToString());
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = new ResultDataType(address, frozen, value);
            this.Tag = resulttype;
        }
        public ResultItem(uint address, bool frozen, sbyte value)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
            this.SubItems.Add(string.Format("0x{0:x2}", value));
            this.SubItems.Add(frozen.ToString());
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = new ResultDataType(address, frozen, value);
            this.Tag = resulttype;
        }
        public ResultItem(uint address, bool frozen, ushort value)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
            this.SubItems.Add(string.Format("0x{0:x4}", value));
            this.SubItems.Add(frozen.ToString());
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = new ResultDataType(address, frozen, value);
            this.Tag = resulttype;
        }
        public ResultItem(uint address, bool frozen, short value)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
            this.SubItems.Add(string.Format("0x{0:x4}", value));
            this.SubItems.Add(frozen.ToString());
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = new ResultDataType(address, frozen, value);
            this.Tag = resulttype;
        }
        public ResultItem(uint address, bool frozen, uint value)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
            this.SubItems.Add(string.Format("0x{0:x8}", value));
            this.SubItems.Add(frozen.ToString());
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = new ResultDataType(address, frozen, value);
            this.Tag = resulttype;
        }
        public ResultItem(uint address, bool frozen, int value)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
            this.SubItems.Add(string.Format("0x{0:x8}", value));
            this.SubItems.Add(frozen.ToString());
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = new ResultDataType(address, frozen, value);
            this.Tag = resulttype;
        }
        public ResultItem(uint address, bool frozen, ulong value)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
            this.SubItems.Add(string.Format("0x{0:x16}", value));
            this.SubItems.Add(frozen.ToString());
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = new ResultDataType(address, frozen, value);
            this.Tag = resulttype;
        }
        public ResultItem(uint address, bool frozen, long value)
            : base()
        {
            this.initialize(frozen);
            this.SubItems.Add(string.Format("0x{0:x8}", address));
            this.SubItems.Add(string.Format("0x{0:x16}", value));
            this.SubItems.Add(frozen.ToString());
#if HAVE_LISTVIEW_FREEZE_BUTTON
            this.SubItems.Add(btnFreezeToggle.Toggle(frozen));
#endif
            ResultDataType resulttype = new ResultDataType(address, frozen, value);
            this.Tag = resulttype;
        }
    }
    public class ResultSubItem : ListViewItem.ListViewSubItem
    {
    }
    [Serializable]
    public class ResultItemCollection : System.Windows.Forms.ListView.ListViewItemCollection
    {
        public ResultItemCollection(ListView owner)
            : base(owner)
        {
        }



        #region Overriden Members
        //#region This Members
        //public new ResultItem this[int index]
        //{
        //    get
        //    {
        //        return base[index] as ResultItem;
        //    }
        //    set
        //    {
        //        base[index] = value as ListViewItem;
        //    }
        //}
        //public new ResultItem this[string key]
        //{
        //    get
        //    {
        //        return base[key] as ResultItem;
        //    }
        //}
        //#endregion
        #region Add Members

        public ResultItem Add(ResultItem value)
        {
            return (ResultItem)base.Add(value);
        }

        public override ListViewItem Add(ListViewItem value)
        {
            return base.Add(value);
        }
        public override ListViewItem Add(string key, string text, int imageIndex)
        {
            return base.Add(key, text, imageIndex);
        }
        public override ListViewItem Add(string key, string text, string imageKey)
        {
            return base.Add(key, text, imageKey);
        }
        public override ListViewItem Add(string text)
        {
            return base.Add(text);
        }
        public override ListViewItem Add(string text, int imageIndex)
        {
            return base.Add(text, imageIndex);
        }
        public override ListViewItem Add(string text, string imageKey)
        {
            return base.Add(text, imageKey);
        }
        #endregion
        #region Remove Members
        public override void Remove(ListViewItem item)
        {
            base.Remove(item);
        }
        #endregion

        #region Contains Members
        public new bool Contains(ListViewItem item)
        {
            try
            {
                return this.Contains((ResultItem)item);
            }
            catch (InvalidCastException ex)
            {
                Exception ex1 = new Exception("Unable to Convert ListViewItem to ResultItem in ResultItemCollection.Contains(ListViewItem item)", ex);
                logger.Error.WriteLine("avp.contains(ListViewItem item): invalid cast");
                logger.Error.WriteLine(ex1.ToString());
                return false;
            }
            catch (Exception ex)
            {
                logger.Error.WriteLine("avp.contains(): exception");
                logger.Error.WriteLine(ex.ToString());
                return false;
            }
        }
        public bool Contains(ResultItem item)
        {
            try
            {
                //ResultItem _item = (ResultItem)item;

                bool contains = false;
                if (!(this.Count > 0)) return false;
                foreach (ResultItem iter in this)
                {
                    if (item.ToString() == iter.ToString()) contains = true;
                }
                return contains;
            }
            catch (IndexOutOfRangeException)
            {
                return false;
            }
            catch (ArgumentOutOfRangeException)
            {
                return false;
            }
            catch (Exception ex)
            {
                Exception ex1 = new Exception("Caught non-Argument or Index OutOfRangeException in: ResultItemCollection.Contains(ListViewItem item, int index)", ex);
                logger.Error.WriteLine("avp.contains(ResultItem item): Exception");
                logger.Error.WriteLine(ex1.ToString());
                return false;
            }
        }
        public override bool ContainsKey(string key)
        {
            return base.ContainsKey(key);
        }
        #endregion

        #endregion
    }
    #endregion

    public interface IAvpFreeze
    {
        bool ItemIsFrozen(int index);
        void FreezeItem(int index);
        void ThawItem(int index);
        int ProcessID { get; set; }
    }

    public interface IAvpExport
    {
        bool ExportToClipboard();
        bool ExportToFile();
        bool ExportToFile(string filename);
    }
    public interface IAvpImport
    {
        bool ImportFromClipboard();
        bool ImportFromFile();
        bool ImportFromFile(string filename);
    }
    public interface IAvpLvSupport
    {
        System.Windows.Forms.View View { get; set; }
        bool OverrideDetailsViewByDefault { get; set; }
        ListView.ColumnHeaderCollection Columns { get; }
        ResultItemCollection Items { get; }
    }
    public interface IAvpLvColumnSupport
    {
        int GetColumnByType(AVPColumnType AVPColumnType);
        int GetColumnByKey(string AVPColumnType);
    }

    public class AVPIconKeys
    {
        public const string FROZEN = "FROZEN";
        public const string NOTFROZEN = "NOTFROZEN";
    }

    #region AVPColumnText Sub-Class
    public interface IAVPColumnText
    {
        string ColumnText { get; }
        string ColumnKey { get; }
        int ColumnIndex { get; }
        int ColumnWidth { get; }
    }
    public class AVPColumnText : IAVPColumnText
    {
        private const string FREEZE_ICON = "";
        private const int FREEZE_ICON_WIDTH = 32;
        private const int FREEZE_ICON_INDEX = 0;
        private const string ADDRESS = "Address";
        private const int ADDRESS_WIDTH = 120;
        private const int ADDRESS_INDEX = 1;
        private const string VALUE = "Value";
        private const int VALUE_WIDTH = 220;
        private const int VALUE_INDEX = 2;
        private const string FROZEN = "Is Frozen";
        private const int FROZEN_WIDTH = 120;
        private const int FROZEN_INDEX = 3;
#if HAVE_LISTVIEW_FREEZE_BUTTON
        private const string FREEZEBUTTON = "Freeze Toggle";
        private const int FREEZEBUTTON_WIDTH = 160;
#endif
        private const string UKNOWN = "Unknown";
        private const int UKNOWN_WIDTH = 125;
        private const int UKNOWN_INDEX = -1;

        private AVPColumnType _AVPColumnType;
        public AVPColumnText()
        {
            _AVPColumnType = AVPColumnType.UKNOWN;
        }
        public AVPColumnText(AVPColumnType AVPColumnType)
        {
            _AVPColumnType = AVPColumnType;
        }

        #region IAVPColumnText Members
        #region ColumnText
        public string ColumnText
        {
            get
            {
                switch (_AVPColumnType)
                {
                    case AVPColumnType.ICON:
                        return FREEZE_ICON;
                    case AVPColumnType.ADDRESS:
                        return ADDRESS;
                    case AVPColumnType.VALUE:
                        return VALUE;
                    case AVPColumnType.FROZEN:
                        return FROZEN;
#if HAVE_LISTVIEW_FREEZE_BUTTON
                    case AVPColumnType.FREEZE_BUTTON:
                        return FREEZEBUTTON;
#endif
                    default:
                        return UKNOWN;
                }
            }
        }
        #endregion
        #region ColumnKey
        public string ColumnKey
        {
            get
            {
                return Enum.GetName(typeof(AVPColumnType), _AVPColumnType);
            }
        }
        #endregion
        #region ColumnWidth
        public int ColumnWidth
        {
            get
            {
                switch (_AVPColumnType)
                {
                    case AVPColumnType.ICON:
                        return FREEZE_ICON_WIDTH;
                    case AVPColumnType.ADDRESS:
                        return ADDRESS_WIDTH;
                    case AVPColumnType.VALUE:
                        return VALUE_WIDTH;
                    case AVPColumnType.FROZEN:
                        return FROZEN_WIDTH;
#if HAVE_LISTVIEW_FREEZE_BUTTON
                    case AVPColumnType.FREEZE_BUTTON:
                        return FREEZEBUTTON_WIDTH;
#endif
                    default:
                        return UKNOWN_WIDTH;
                }
            }
        }
        #endregion
        #region ColumnIndex
        public int ColumnIndex
        {
            get
            {
                switch (_AVPColumnType)
                {
                    case AVPColumnType.ICON:
                        return FREEZE_ICON_INDEX;
                    case AVPColumnType.ADDRESS:
                        return ADDRESS_INDEX;
                    case AVPColumnType.VALUE:
                        return VALUE_INDEX;
                    case AVPColumnType.FROZEN:
                        return FROZEN_INDEX;
#if HAVE_LISTVIEW_FREEZE_BUTTON
                    case AVPColumnType.FREEZE_BUTTON:
                        return FREEZEBUTTON_WIDTH;
#endif
                    default:
                        return UKNOWN_INDEX;
                }
            }
        }
        #endregion
        #endregion
    }
    #endregion
   
}