using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using RomCheater.Interfaces;
using Sojaner.MemoryScanner.MemoryProviers;
using ManagedWinapi;

namespace RomCheater.PluginFramework.Core
{
    /// <summary>
    /// The base class for all plugins
    /// </summary>
    public abstract class PluginBase : IPluginBase
    {
        public PluginBase() { }

        public virtual bool IsNullPlugin { get { return false; } }
        public virtual bool IsGenericPlugin { get { return false; } }
        public IWebBrowserInterface WebBrowserInterface
        {
            get
            {
                if (this.AcceptedConfig != null)
                {
                    if (this.AcceptedConfig.WebBrowserProvider != null)
                    {
                        return this.AcceptedConfig.WebBrowserProvider.GetProvider();
                    }
                }
                return WebBrowserProvider.Empty.GetProvider();
            }
        }
   

        public void ReadProcessMemory(ulong MemoryAddress, ulong bytesToRead, out ulong bytesRead, out byte[] data)
        {
            try
            {
                bytesRead = 0x00;
                data = new byte[bytesToRead];
                if (this.AcceptedConfig == null || this.AcceptedProcess == null) { return; }
                IConfigPlugin config = this.AcceptedConfig;
                Process proc = this.AcceptedProcess;
                using (GenericMemoryProvider provider = new GenericMemoryProvider(config, proc))
                {
                    provider.OpenProvider();
                    provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data);
                    provider.CloseProvider();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public void WriteProcessMemory(long MemoryAddress, byte[] bytesToWrite, out ulong bytesWritten)
        {
            try
            {
                bytesWritten = 0;
                if (this.AcceptedConfig == null || this.AcceptedProcess == null) { return; }
                IConfigPlugin config = this.AcceptedConfig;
                Process proc = this.AcceptedProcess;
                using (GenericMemoryProvider provider = new GenericMemoryProvider(config, proc))
                {
                    provider.OpenProvider();
                    provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten);
                    provider.CloseProvider();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public List<MEMORY_REGION_INFORMATION> QueryMemoryRegions()
        {
            if (this.AcceptedConfig == null || this.AcceptedProcess == null) { return new List<MEMORY_REGION_INFORMATION>(); }
            IConfigPlugin config = this.AcceptedConfig;
            Process proc = this.AcceptedProcess;
            List<MEMORY_REGION_INFORMATION> MemoryRegions = new List<MEMORY_REGION_INFORMATION>();
            using (GenericMemoryProvider provider = new GenericMemoryProvider(config, proc))
            {
                provider.OpenProvider();
                if (this.peData != null)
                {
                    if (this.peData.Is32bitAssembly())
                    {
                        MemoryRegions = provider.QueryMemoryRegions(MemorySizeConstants.MinimumAddress, MemorySizeConstants.MaximumAddressSize_x86);
                    }
                    else
                    {
                        MemoryRegions = provider.QueryMemoryRegions(MemorySizeConstants.MinimumAddress, MemorySizeConstants.MaximumAddressSize_x64);
                    }
                }
                else
                {
                    MemoryRegions = provider.QueryMemoryRegions(MemorySizeConstants.MinimumAddress, MemorySizeConstants.MaximumAddressSize_x86);
                }                
                provider.CloseProvider();
            }
            return MemoryRegions;
        }
        #region IPluginBase Members
        public abstract Guid ID { get; }
        public abstract string Name { get; }
        public abstract string Description { get; }
        public virtual void Reload() { Reload(false); }
        public abstract void Reload(bool silent);
        #endregion
        public override string ToString()
        {
            return string.Format("{0} [{1}]", Name, ID.ToString());
        }

        private IPEDData _peData;
        protected IPEDData peData { get { return _peData; } }
        public void SetPEViewerData(IPEDData peData)
        {
            _peData = peData;
            if (OnPEDataUpdated != null)
            {
                OnPEDataUpdated.Invoke(new PEViewerDataUpdatedEventArgs(this, peData));
            }
        }

        private Process _AcceptedProcess;
        protected Process AcceptedProcess { get { return _AcceptedProcess; } }
        public void SetAcceptedProcess(Process proc)
        {
            _AcceptedProcess = proc;
            if (OnSelectedProcessChanged != null)
            {
                OnSelectedProcessChanged.Invoke(new ProcessChangedEventArgs(this, proc.Id));
            }
        }

        private IConfigPlugin _AcceptedConfig;
        protected IConfigPlugin AcceptedConfig { get { return _AcceptedConfig; } }
        public void SetAcceptedConfig(IConfigPlugin config)
        {
            _AcceptedConfig = config;
            if (OnSelectedConfigChanged != null)
            {
                OnSelectedConfigChanged.Invoke(new ConfigChangedEventArgs(this, config));
            }
        }


        public void SetAcceptedProcessAndConfig(IAcceptsProcessAndConfig iapc)
        {
            SetAcceptedConfig(iapc.AcceptedPlugin);
            SetAcceptedProcess(iapc.AcceptedProcess);
        }

        public event BaseEventHandler<PEViewerDataUpdatedEventArgs> OnPEDataUpdated;
        public event BaseEventHandler<ProcessChangedEventArgs> OnSelectedProcessChanged;
        public event BaseEventHandler<ConfigChangedEventArgs> OnSelectedConfigChanged;

        public void RaisePluginFrameworkEvents()
        {
            if (this.OnPEDataUpdated != null)
            {
                if (this.peData != null)
                {
                    this.OnPEDataUpdated.Invoke(new PEViewerDataUpdatedEventArgs(this, this.peData));
                }
            }
            if (this.OnSelectedProcessChanged != null)
            {
                if (this.AcceptedProcess != null)
                {
                    this.OnSelectedProcessChanged.Invoke(new ProcessChangedEventArgs(this, this.AcceptedProcess.Id));
                }
            }
            if (this.OnSelectedConfigChanged != null)
            {
                if (this.AcceptedConfig != null)
                {
                    this.OnSelectedConfigChanged.Invoke(new ConfigChangedEventArgs(this, this.AcceptedConfig));
                }
            }
        }
    }
}