using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;

namespace ExtractResFile.AsposeHook
{
    public static class HookManager
    {
        private static MethodHook mCompareHook;

        private static MethodHook mGreaterThanHook;

        private static MethodHook mParseExactHook;

        private static MethodHook mInnerTextHook;

        private static MethodHook mIndexOfHook;

        private static MethodHook mStringSplitHook;

        private static MethodHook mMethodInvokeHook;

        private static List<string> mAssembliesLicenseSetted = new List<string>();

        private static List<MethodHook> mMethodHookList = new List<MethodHook>();

        private static readonly string DATE_CHANGED_TO = DateTime.Today.Year + 1 + "0827";

        private const string LICENSE_STRING = "PExpY2Vuc2U+CiAgPERhdGE+CiAgICA8TGljZW5zZWRUbz5TdXpob3UgQXVuYm94IFNvZnR3YXJlIENvLiwgTHRkLjwvTGljZW5zZWRUbz4KICAgIDxFbWFpbFRvPnNhbGVzQGF1bnRlYy5jb208L0VtYWlsVG8+CiAgICA8TGljZW5zZVR5cGU+RGV2ZWxvcGVyIE9FTTwvTGljZW5zZVR5cGU+CiAgICA8TGljZW5zZU5vdGU+TGltaXRlZCB0byAxIGRldmVsb3BlciwgdW5saW1pdGVkIHBoeXNpY2FsIGxvY2F0aW9uczwvTGljZW5zZU5vdGU+CiAgICA8T3JkZXJJRD4xOTA4MjYwODA3NTM8L09yZGVySUQ+CiAgICA8VXNlcklEPjEzNDk3NjAwNjwvVXNlcklEPgogICAgPE9FTT5UaGlzIGlzIGEgcmVkaXN0cmlidXRhYmxlIGxpY2Vuc2U8L09FTT4KICAgIDxQcm9kdWN0cz4KICAgICAgPFByb2R1Y3Q+QXNwb3NlLlRvdGFsIGZvciAuTkVUPC9Qcm9kdWN0PgogICAgPC9Qcm9kdWN0cz4KICAgIDxFZGl0aW9uVHlwZT5FbnRlcnByaXNlPC9FZGl0aW9uVHlwZT4KICAgIDxTZXJpYWxOdW1iZXI+M2U0NGRlMzAtZmNkMi00MTA2LWIzNWQtNDZjNmEzNzE1ZmMyPC9TZXJpYWxOdW1iZXI+CiAgICA8U3Vic2NyaXB0aW9uRXhwaXJ5PjIwMjAwODI3PC9TdWJzY3JpcHRpb25FeHBpcnk+CiAgICA8TGljZW5zZVZlcnNpb24+My4wPC9MaWNlbnNlVmVyc2lvbj4KICAgIDxMaWNlbnNlSW5zdHJ1Y3Rpb25zPmh0dHBzOi8vcHVyY2hhc2UuYXNwb3NlLmNvbS9wb2xpY2llcy91c2UtbGljZW5zZTwvTGljZW5zZUluc3RydWN0aW9ucz4KICA8L0RhdGE+CiAgPFNpZ25hdHVyZT53UGJtNUt3ZTYvRFZXWFNIY1o4d2FiVEFQQXlSR0pEOGI3L00zVkV4YWZpQnd5U2h3YWtrNGI5N2c2eGtnTjhtbUFGY3J0c0cwd1ZDcnp6MytVYk9iQjRYUndTZWxsTFdXeXNDL0haTDNpN01SMC9jZUFxaVZFOU0rWndOQkR4RnlRbE9uYTFQajhQMzhzR1grQ3ZsemJLZFZPZXk1S3A2dDN5c0dqYWtaL1E9PC9TaWduYXR1cmU+CjwvTGljZW5zZT4=";

        private static void Initialize()
        {
            if (mMethodHookList.Count == 0)
            {
                try
                {
                    MethodInfo method = typeof(MethodBase).GetMethod("Invoke", BindingFlags.Instance | BindingFlags.Public, null, new Type[2]
                    {
                    typeof(object),
                    typeof(object[])
                    }, null);
                    MethodInfo method2 = typeof(HookManager).GetMethod("NewMethodInvoke", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
                    {
                    typeof(MethodBase),
                    typeof(object),
                    typeof(object[])
                    }, null);
                    mMethodInvokeHook = new MethodHook(method, method2);
                    mMethodHookList.Add(mMethodInvokeHook);
                }
                catch (Exception ex)
                {
                    Utils.LogWriteLine("Initialize method XmlElement.InnerText.Get error:" + ex.Message, ConsoleColor.DarkRed);
                }

                try
                {
                    MethodInfo method3 = typeof(DateTime).GetMethod("ParseExact", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
                    {
                    typeof(string),
                    typeof(string),
                    typeof(IFormatProvider)
                    }, null);
                    MethodInfo method4 = typeof(HookManager).GetMethod("NewParseExact", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
                    {
                    typeof(string),
                    typeof(string),
                    typeof(IFormatProvider)
                    }, null);
                    mParseExactHook = new MethodHook(method3, method4);
                }
                catch (Exception ex2)
                {
                    Utils.LogWriteLine("Initialize method DateTime.ParseExact error:" + ex2.Message, ConsoleColor.DarkRed);
                }

                try
                {
                    MethodInfo method5 = typeof(DateTime).GetMethod("op_GreaterThan", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
                    {
                    typeof(DateTime),
                    typeof(DateTime)
                    }, null);
                    MethodInfo method6 = typeof(HookManager).GetMethod("NewGreaterThan", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
                    {
                    typeof(DateTime),
                    typeof(DateTime)
                    }, null);
                    mGreaterThanHook = new MethodHook(method5, method6);
                }
                catch (Exception ex3)
                {
                    Utils.LogWriteLine("Initialize method DateTime.op_GreaterThan error:" + ex3.Message, ConsoleColor.DarkRed);
                }

                try
                {
                    MethodInfo method7 = typeof(string).GetMethod("Compare", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
                    {
                    typeof(string),
                    typeof(string)
                    }, null);
                    MethodInfo method8 = typeof(HookManager).GetMethod("NewCompare", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
                    {
                    typeof(string),
                    typeof(string)
                    }, null);
                    mCompareHook = new MethodHook(method7, method8);
                    mMethodHookList.Add(mCompareHook);
                }
                catch (Exception ex4)
                {
                    Utils.LogWriteLine("Initialize method string.Compare error:" + ex4.Message, ConsoleColor.DarkRed);
                }

                try
                {
                    MethodInfo method9 = typeof(string).GetMethod("IndexOf", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
                    MethodInfo method10 = typeof(HookManager).GetMethod("NewIndexOf", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
                    {
                    typeof(string),
                    typeof(string)
                    }, null);
                    mIndexOfHook = new MethodHook(method9, method10);
                }
                catch (Exception ex5)
                {
                    Utils.LogWriteLine("Initialize method string.IndexOf error:" + ex5.Message, ConsoleColor.DarkRed);
                }

                try
                {
                    MethodInfo getMethod = typeof(XmlElement).GetProperty("InnerText", BindingFlags.Instance | BindingFlags.Public).GetMethod;
                    MethodInfo method11 = typeof(HookManager).GetMethod("NewInnerText", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(XmlElement) }, null);
                    mInnerTextHook = new MethodHook(getMethod, method11);
                }
                catch (Exception ex6)
                {
                    Utils.LogWriteLine("Initialize method XmlElement.InnerText.Get error:" + ex6.Message, ConsoleColor.DarkRed);
                }

                try
                {
                    MethodInfo method12 = typeof(string).GetMethod("Split", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(char[]) }, null);
                    MethodInfo method13 = typeof(HookManager).GetMethod("NewStringSplitForNET4", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
                    {
                    typeof(string),
                    typeof(char[])
                    }, null);
                    mStringSplitHook = new MethodHook(method12, method13);
                }
                catch (Exception ex7)
                {
                    Utils.LogWriteLine("Initialize method string.Split error:" + ex7.Message, ConsoleColor.DarkRed);
                }
            }
        }

        public static void ShowHookDetails(bool show)
        {
            if (show)
            {
                Utils.EnableLog();
            }
            else
            {
                Utils.DisableLog();
            }
        }

        public static void StartHook()
        {
            try
            {
                Initialize();
                mMethodHookList.ForEach(delegate (MethodHook item)
                {
                    item?.StartHook();
                });
                IEnumerable<AssemblyName> enumerable = (from assembly in Assembly.GetCallingAssembly()?.GetReferencedAssemblies().Union(Assembly.GetEntryAssembly()?.GetReferencedAssemblies() ?? new AssemblyName[0])
                                                        group assembly by assembly.Name into item
                                                        select item.FirstOrDefault() into assembly
                                                        where assembly.Name.StartsWith("Aspose") && !assembly.Name.StartsWith("Aspose.Hook")
                                                        select assembly);
                if (enumerable == null)
                {
                    return;
                }

                foreach (AssemblyName item in enumerable)
                {
                    if (!mAssembliesLicenseSetted.Contains(item.FullName))
                    {
                        Type type = Assembly.Load(item).GetType(item.Name + ".License");
                        if (type == null)
                        {
                            type = Assembly.Load(item).GetType(Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(item.Name.ToLower()) + ".License");
                        }

                        if (type != null)
                        {
                            Utils.LogWriteLine("\nSETTING..." + type.FullName, ConsoleColor.Yellow);
                            object obj = Activator.CreateInstance(type);
                            MethodInfo? method = type.GetMethod("SetLicense", new Type[1] { typeof(Stream) });
                            object[] parameters = new MemoryStream[1]
                            {
                            new MemoryStream(Convert.FromBase64String("PExpY2Vuc2U+CiAgPERhdGE+CiAgICA8TGljZW5zZWRUbz5TdXpob3UgQXVuYm94IFNvZnR3YXJlIENvLiwgTHRkLjwvTGljZW5zZWRUbz4KICAgIDxFbWFpbFRvPnNhbGVzQGF1bnRlYy5jb208L0VtYWlsVG8+CiAgICA8TGljZW5zZVR5cGU+RGV2ZWxvcGVyIE9FTTwvTGljZW5zZVR5cGU+CiAgICA8TGljZW5zZU5vdGU+TGltaXRlZCB0byAxIGRldmVsb3BlciwgdW5saW1pdGVkIHBoeXNpY2FsIGxvY2F0aW9uczwvTGljZW5zZU5vdGU+CiAgICA8T3JkZXJJRD4xOTA4MjYwODA3NTM8L09yZGVySUQ+CiAgICA8VXNlcklEPjEzNDk3NjAwNjwvVXNlcklEPgogICAgPE9FTT5UaGlzIGlzIGEgcmVkaXN0cmlidXRhYmxlIGxpY2Vuc2U8L09FTT4KICAgIDxQcm9kdWN0cz4KICAgICAgPFByb2R1Y3Q+QXNwb3NlLlRvdGFsIGZvciAuTkVUPC9Qcm9kdWN0PgogICAgPC9Qcm9kdWN0cz4KICAgIDxFZGl0aW9uVHlwZT5FbnRlcnByaXNlPC9FZGl0aW9uVHlwZT4KICAgIDxTZXJpYWxOdW1iZXI+M2U0NGRlMzAtZmNkMi00MTA2LWIzNWQtNDZjNmEzNzE1ZmMyPC9TZXJpYWxOdW1iZXI+CiAgICA8U3Vic2NyaXB0aW9uRXhwaXJ5PjIwMjAwODI3PC9TdWJzY3JpcHRpb25FeHBpcnk+CiAgICA8TGljZW5zZVZlcnNpb24+My4wPC9MaWNlbnNlVmVyc2lvbj4KICAgIDxMaWNlbnNlSW5zdHJ1Y3Rpb25zPmh0dHBzOi8vcHVyY2hhc2UuYXNwb3NlLmNvbS9wb2xpY2llcy91c2UtbGljZW5zZTwvTGljZW5zZUluc3RydWN0aW9ucz4KICA8L0RhdGE+CiAgPFNpZ25hdHVyZT53UGJtNUt3ZTYvRFZXWFNIY1o4d2FiVEFQQXlSR0pEOGI3L00zVkV4YWZpQnd5U2h3YWtrNGI5N2c2eGtnTjhtbUFGY3J0c0cwd1ZDcnp6MytVYk9iQjRYUndTZWxsTFdXeXNDL0haTDNpN01SMC9jZUFxaVZFOU0rWndOQkR4RnlRbE9uYTFQajhQMzhzR1grQ3ZsemJLZFZPZXk1S3A2dDN5c0dqYWtaL1E9PC9TaWduYXR1cmU+CjwvTGljZW5zZT4="))
                            };
                            method.Invoke(obj, BindingFlags.Instance | BindingFlags.Public, null, parameters, null);
                            Utils.LogWriteLine(type.FullName + " SET SUCCESSFULLY.", ConsoleColor.Yellow);
                            mAssembliesLicenseSetted.Add(item.FullName);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Exception ex2 = ex;
                while (ex2.InnerException != null)
                {
                    ex2 = ex2.InnerException;
                }

                Utils.LogWriteLine("start hook failed because of " + ex2.Message + ".", ConsoleColor.Red);
            }
        }

        public static void StopHook()
        {
            mMethodHookList.ForEach(delegate (MethodHook item)
            {
                item?.StopHook();
            });
        }

        public static object NewMethodInvoke(MethodBase method, object obj, object[] parameters)
        {
            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "ParseExact" && parameters.Length != 0 && parameters[0].ToString().Contains("0827"))
            {
                DateTime dateTime = DateTime.ParseExact(DATE_CHANGED_TO, "yyyyMMdd", CultureInfo.InvariantCulture);
                ShowLog(method, dateTime, obj, parameters);
                return dateTime;
            }

            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "ParseExact" && parameters.Length != 0 && parameters[0].ToString() == DateTime.Now.ToString("yyyy.MM.01"))
            {
                DateTime dateTime2 = DateTime.ParseExact("20200501", "yyyyMMdd", CultureInfo.InvariantCulture);
                ShowLog(method, dateTime2, obj, parameters);
                return dateTime2;
            }

            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "get_InnerText1" && obj is XmlElement && (obj as XmlElement).Name == "SubscriptionExpiry")
            {
                ShowLog(method, DATE_CHANGED_TO, obj, parameters);
                return DATE_CHANGED_TO;
            }

            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "get_Ticks" && obj is DateTime dateTime3 && dateTime3.ToString("MMdd") == "0827")
            {
                long ticks = DateTime.ParseExact(DATE_CHANGED_TO, "yyyyMMdd", CultureInfo.InvariantCulture).Ticks;
                ShowLog(method, ticks, obj, parameters);
                return ticks;
            }

            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "Compare")
            {
                return DATE_CHANGED_TO;
            }

            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "op_GreaterThan" && parameters.Length == 2 && parameters[1] is DateTime && ((DateTime)parameters[1]).ToString("MMdd") == "0827")
            {
                ShowLog(method, false, obj, parameters);
                return false;
            }

            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "IndexOf" && parameters.Length != 0 && parameters[0].ToString().Contains("0827"))
            {
                ShowLog(method, 580, obj, parameters);
                return 580;
            }

            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "Split" && Regex.Match(obj.ToString(), "^\\d{4}\\.\\d{2}\\.\\d{2}$").Success && obj != null && obj.ToString().Substring(0, 4) == DateTime.Now.Year.ToString())
            {
                ShowLog(method, "new string[] { \"2019\", \"08\", \"27\" }", obj, parameters);
                return new string[3] { "2019", "08", "27" };
            }

            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "get_Now")
            {
                DateTime dateTime4 = DateTime.ParseExact("20200518", "yyyyMMdd", CultureInfo.InvariantCulture);
                ShowLog(method, dateTime4, obj, parameters);
                return dateTime4;
            }

            return mMethodInvokeHook.InvokeOriginal<object>(method, new object[2]
            {
            obj,
            parameters.ToArray()
            });
        }

        private static void ShowLog(MethodBase method, object ret, object obj, object[] parameters)
        {
            if (method.Name == "GetBytes" || method.Name == "GetManifestResourceNames" || method.Name == "get_DocumentElement" || method.Name == "get_FirstChild" || method.Name == "op_Equality" || method.Name == "get_LocalName" || method.Name == "Append" || method.Name == "get_Chars" || method.Name == "Write" || method.Name == "get_Length" || method.Name == "WriteByte" || (obj == null && parameters.Length == 1 && parameters[0] is int && (int)parameters[0] < 0))
            {
                return;
            }

            string empty = string.Empty;
            try
            {
                empty = ((obj is Stream || parameters == null || parameters.Length == 0 || parameters.Where((object item) => item is Stream || item is StreamingContext).Count() != 0) ? (obj?.ToString() + "," + parameters) : (JsonConvert.SerializeObject(obj) + "," + JsonConvert.SerializeObject((object)parameters)));
            }
            catch (Exception)
            {
                empty = obj?.ToString() + "," + parameters;
            }

            string empty2 = string.Empty;
            try
            {
                empty2 = ((!(ret is Stream)) ? JsonConvert.SerializeObject(ret) : "<STREAM>...");
            }
            catch (Exception)
            {
                empty2 = ret.ToString();
            }

            Utils.LogWriteLine("INVOKE method " + method.Name + "(" + empty + ") RETURN=> " + empty2, ConsoleColor.DarkGray);
        }

        public static int NewCompare(string s1, string s2)
        {
            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && s2 == "20200827")
            {
                Utils.LogWriteLine("HOOK SUCCESS: From " + Assembly.GetCallingAssembly().GetName().Name + " String.Compare(" + s1 + "," + s2 + ") return -1;", ConsoleColor.Green);
                return -1;
            }

            return mCompareHook.InvokeOriginal<int>(null, new object[2] { s1, s2 });
        }

        public static bool NewGreaterThan(DateTime t1, DateTime t2)
        {
            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && t2.ToString("yyyyMMdd") == "20200827")
            {
                Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} DateTime ({t1}>{t2}) return false;", ConsoleColor.Green);
                return false;
            }

            return mGreaterThanHook.InvokeOriginal<bool>(null, new object[2] { t1, t2 });
        }

        public static DateTime NewParseExact(string s, string format, IFormatProvider provider)
        {
            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && s == "20200827")
            {
                Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} DateTime.ParseExact({s},{format},{provider}) return {DATE_CHANGED_TO};", ConsoleColor.Green);
                return mParseExactHook.InvokeOriginal<DateTime>(null, new object[3] { DATE_CHANGED_TO, format, provider });
            }

            return mParseExactHook.InvokeOriginal<DateTime>(null, new object[3] { s, format, provider });
        }

        public static string NewInnerText(XmlElement element)
        {
            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && !Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.Words") && !Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.Hook") && element.Name == "SubscriptionExpiry")
            {
                Utils.LogWriteLine("HOOK SUCCESS: From " + Assembly.GetCallingAssembly().GetName().Name + " XmlElement.InnerText (" + element.Name + "," + element.InnerXml + ") return " + DATE_CHANGED_TO + ";", ConsoleColor.Green);
                return DATE_CHANGED_TO;
            }

            return mInnerTextHook.InvokeOriginal<string>(element, Array.Empty<object>());
        }

        public static int NewIndexOf(string v1, string v2)
        {
            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && v2 == DATE_CHANGED_TO)
            {
                Utils.LogWriteLine("HOOK SUCCESS: From " + Assembly.GetCallingAssembly().GetName().Name + " " + v1.ToString().Substring(0, 9) + "....IndexOf(" + v2 + ") return 580;", ConsoleColor.Green);
                return 580;
            }

            return mIndexOfHook.InvokeOriginal<int>(v1, new object[1] { v2 });
        }

        public static string[] NewStringSplitForNET6(string value, char separator, StringSplitOptions options)
        {
            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && value != null && value.Length == 10 && Regex.Match(value, "^\\d{4}\\.\\d{2}\\.\\d{2}$").Success && separator == '.' && options == StringSplitOptions.None)
            {
                Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} String.Split({value},{separator}) return 20190827;", ConsoleColor.Green);
                return new string[3] { "2019", "08", "27" };
            }

            return mStringSplitHook.InvokeOriginal<string[]>(value, new object[2] { separator, options });
        }

        public static string[] NewStringSplitForNET4(string value, char[] separator)
        {
            if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && value != null && value.Length == 10 && Regex.Match(value, "^\\d{4}\\.\\d{2}\\.\\d{2}$").Success && separator != null && separator.Length != 0 && separator[0] == '.')
            {
                Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} String.Split({value},{separator}) return 20190827;", ConsoleColor.Green);
                return new string[3] { "2019", "08", "27" };
            }

            return mStringSplitHook.InvokeOriginal<string[]>(value, new object[1] { separator });
        }
    }
}