using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Threading;

namespace CC_Functions.Core
{
    /// <summary>
    ///     Extension methods for various types
    /// </summary>
    public static class GenericExtensions
    {
        /// <summary>
        ///     Gets an element from the dictionary or adds the default
        /// </summary>
        /// <param name="dict">The dictionary to get from</param>
        /// <param name="key">The key to check</param>
        /// <param name="def">The default value to place</param>
        /// <typeparam name="TKey">The key type</typeparam>
        /// <typeparam name="TValue">The value type</typeparam>
        /// <returns>The element at the key</returns>
        public static TValue Get<TKey, TValue>(this IDictionary<TKey, TValue> dict, TKey key, TValue def = default)
        {
            if (!dict.ContainsKey(key))
                dict[key] = def;
            return dict[key];
        }

        /// <summary>
        ///     Sets an element and returns it
        /// </summary>
        /// <param name="dict">The dictionary to set in</param>
        /// <param name="key">The key to set at</param>
        /// <param name="val">The value to place</param>
        /// <typeparam name="TKey">The key type</typeparam>
        /// <typeparam name="TValue">The value type</typeparam>
        /// <returns>The value that was placed</returns>
        public static TValue Set<TKey, TValue>(this IDictionary<TKey, TValue> dict, TKey key, TValue val = default)
        {
            dict[key] = val;
            return dict[key];
        }

        /// <summary>
        ///     Tries to cast an object
        /// </summary>
        /// <param name="o">The object to try to parse</param>
        /// <param name="parsed">The parsed object (if successful) or the default (usually null)</param>
        /// <typeparam name="T">The type to cast to</typeparam>
        /// <returns>Whether the cast was successful</returns>
        public static bool TryCast<T>(this object o, out T parsed)
        {
            try
            {
                parsed = (T) o;
                return true;
            }
            catch
            {
                parsed = default;
                return false;
            }
        }

        /// <summary>
        ///     Runs a function that transforms an object in-line
        /// </summary>
        /// <param name="self">The object to run on</param>
        /// <param name="func">The function to run</param>
        /// <typeparam name="TIn">The input type</typeparam>
        /// <typeparam name="TOut">The output type</typeparam>
        /// <returns></returns>
        public static TOut SelectO<TIn, TOut>(this TIn self, Func<TIn, TOut> func) => func.Invoke(self);

        /// <summary>
        ///     Runs a function under a condition in-line (equal to if)
        /// </summary>
        /// <param name="condition">The condition to check</param>
        /// <param name="func">The function to run</param>
        public static void RunIf(bool condition, Action func)
        {
            if (condition)
                func();
        }

        /// <summary>
        ///     Parses a string to a value of an enum
        /// </summary>
        /// <param name="value">The string to parse</param>
        /// <typeparam name="TEnum">The enum type (MUST be an enum)</typeparam>
        /// <returns>The element</returns>
        public static TEnum ParseToEnum<TEnum>(string value) => (TEnum) Enum.Parse(typeof(TEnum),
            Enum.GetNames(typeof(TEnum)).First(s => s.ToLower() == value.ToLower()));

        /// <summary>
        ///     Parses a string to a nullable bool (defaults to null if parse fails)
        /// </summary>
        /// <param name="value">The st string to parse</param>
        /// <returns>The output nullable bool</returns>
        public static bool? ParseBool(string value) =>
            bool.TryParse(value, out bool tmp) ? (bool?) tmp : null;

        /// <summary>
        ///     AND operation for nullable bools (uses <see cref="True">True</see>)
        /// </summary>
        /// <param name="left">First bool to check</param>
        /// <param name="right">Second bool to check</param>
        /// <returns>The operation result</returns>
        public static bool And(this bool? left, bool? right) => left.True() && right.True();

        /// <summary>
        ///     OR operation for nullable bools (uses <see cref="True">True</see>)
        /// </summary>
        /// <param name="left">First bool to check</param>
        /// <param name="right">Second bool to check</param>
        /// <returns>The operation result</returns>
        public static bool Or(this bool? left, bool? right) => left.True() || right.True();

        /// <summary>
        ///     XOR operation for nullable bools (uses <see cref="True">True</see>)
        /// </summary>
        /// <param name="left">First bool to check</param>
        /// <param name="right">Second bool to check</param>
        /// <returns>The operation result</returns>
        public static bool Xor(this bool? left, bool? right) => left.Or(right) && !left.And(right);

        /// <summary>
        ///     Whether the nullable bool is true (null->false)
        /// </summary>
        /// <param name="self">Value to check</param>
        /// <returns>Whether it is true</returns>
        public static bool True(this bool? self) => self == true;

        /// <summary>
        ///     Whether the nullable bool is false (null->false)
        /// </summary>
        /// <param name="self">Value to check</param>
        /// <returns>Whether it is false</returns>
        public static bool False(this bool? self) => self == false;

        /// <summary>
        ///     Whether the nullable bool is null
        /// </summary>
        /// <param name="self">Value to check</param>
        /// <returns>Whether it is null</returns>
        public static bool Null(this bool? self) => self == null;

        /// <summary>
        ///     Removes an element from a dictionary by its index (not key)
        /// </summary>
        /// <param name="dict">The dictionary to remove from</param>
        /// <param name="index">The index of the value</param>
        /// <typeparam name="TKey">The key type</typeparam>
        /// <typeparam name="TValue">The value type</typeparam>
        public static void RemoveAt<TKey, TValue>(this Dictionary<TKey, TValue> dict, int index) =>
            dict.Remove(dict.Keys.ToArray()[index]);

        /// <summary>
        ///     "Unshorten" (follow) an URL
        /// </summary>
        /// <param name="self">The URL to unshorten</param>
        /// <returns>The unshortened URL</returns>
        public static Uri Unshorten(this Uri self)
        {
            HttpWebRequest req = (HttpWebRequest) WebRequest.Create(self);
            req.AllowAutoRedirect = true;
            req.MaximumAutomaticRedirections = 100;
            WebResponse resp = req.GetResponse();
            return resp.ResponseUri;
        }

        /// <summary>
        ///     Rounds a RectangleF to a Rectangle instead of flooring
        /// </summary>
        /// <param name="self">The RectangleF to round</param>
        /// <returns>The rounded Rectangle</returns>
        public static Rectangle Round(this RectangleF self) => Rectangle.Round(self);

        /// <summary>
        ///     Ceilings a RectangleF to a Rectangle instead of flooring
        /// </summary>
        /// <param name="self">The RectangleF to ceil (?)</param>
        /// <returns>The ceiled (?) Rectangle</returns>
        public static Rectangle Ceiling(this RectangleF self) => Rectangle.Ceiling(self);
        
        /// <summary>
        ///     Pings an URL to check for availability
        /// </summary>
        /// <param name="self">The URL to check</param>
        /// <returns>Whether the service is online</returns>
        public static bool Ping(this Uri self)
        {
            try
            {
                HttpWebRequest request = (HttpWebRequest) WebRequest.Create(self);
                request.Timeout = 3000;
                request.AllowAutoRedirect = true;
                using WebResponse response = request.GetResponse();
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        ///     Gets the size of a dictionary
        /// </summary>
        /// <param name="directory">The dictionary to check</param>
        /// <returns>The size of the dictionary</returns>
        public static long GetSize(this DirectoryInfo directory) => IO.GetDirectorySize(directory.FullName);

        /// <summary>
        ///     Adds a directory to an archive recursively
        /// </summary>
        /// <param name="archive">The archive to add to</param>
        /// <param name="folderPath">The directory to add</param>
        /// <param name="entryName">The name of the directory in-archive</param>
        /// <param name="ignoredExtensions">Extensions for files to ignore</param>
        /// <param name="ignoredPaths">Paths to exclude from adding</param>
        /// <returns>The new entry</returns>
        public static ZipArchiveEntry AddDirectory(this ZipArchive archive, string folderPath, string entryName,
            string[] ignoredExtensions, string[] ignoredPaths)
        {
            entryName = entryName.TrimEnd('/');
            ZipArchiveEntry result = archive.CreateEntry($"{entryName}/");
            string[] files = Directory.GetFiles(folderPath);
            foreach (string t in files)
                if (!ignoredExtensions.Contains(Path.GetExtension(t)) &&
                    !ignoredPaths.Any(s => IO.CheckPathEqual(s, t)))
                    archive.CreateEntryFromFile(t, $"{entryName}/{Path.GetFileName(t)}");
            string[] dirs = Directory.GetDirectories(folderPath);
            foreach (string t in dirs)
                if (!ignoredPaths.Any(s => IO.CheckPathEqual(s, t)))
                    archive.AddDirectory(t, $"{entryName}/{Path.GetFileName(t)}", ignoredExtensions,
                        ignoredPaths);
            return result;
        }
        /// <summary>
        /// Sets the threads cultureInfo properties to InvariantCulture. For testing
        /// </summary>
        /// <param name="thread">The thread to modify</param>
        public static void ForceInvariantCulture(this Thread thread)
        {
            thread.CurrentCulture = CultureInfo.InvariantCulture;
            thread.CurrentUICulture = CultureInfo.InvariantCulture;
        }
    }
}