using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.Json;
using Tango.Serialization;

namespace Tango.Core.ExtensionMethods
{
    public enum MappingFlags
    {
        /// <summary>
        /// All properties will be mapped.
        /// </summary>
        All = 1,

        /// <summary>
        /// Do not map string properties.
        /// </summary>
        NoStrings = 2,

        /// <summary>
        /// Do not map string properties with value of null.
        /// </summary>
        NoNullStrings = 4,

        /// <summary>
        /// Do not map reference types.
        /// </summary>
        NoReferenceTypes = 8,

        /// <summary>
        /// Map only value types.
        /// </summary>
        ValueTypesOnly,
    }

    /// <summary>
    /// Contains <see cref="Object"/> extension methods.
    /// </summary>
    public static class ObjectExtensions
    {
        private static bool _jsonSettingsSet;

        /// <summary>
        /// Performs shallow cloning of the object excluding generic properties..
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj">The object.</param>
        /// <returns></returns>
        public static T ShallowClone<T>(this T obj)
        {
            var cloned = Activator.CreateInstance<T>();

            foreach (var prop in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(x => x.SetMethod != null))
            {
                if (!prop.PropertyType.IsGenericTypeAndNotNullable())
                {
                    prop.SetValue(cloned, prop.GetValue(obj));
                }
            }

            return cloned;
        }

        /// <summary>
        /// Performs a shallow mapping to the specified object excluding generic properties.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source">The source.</param>
        /// <param name="destination">The destination object.</param>
        public static void ShallowCopyTo<T>(this T source, T destination)
        {
            foreach (var prop in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(x => x.SetMethod != null))
            {
                if (!prop.PropertyType.IsGenericTypeAndNotNullable())
                {
                    prop.SetValue(destination, prop.GetValue(source));
                }
            }
        }

        /// <summary>
        /// Maps the object primitive properties values to the destination object.
        /// </summary>
        /// <param name="source">The source object.</param>
        /// <param name="destination">The destination object.</param>
        /// <param name="flags">The mapping flags.</param>
        /// <param name="condition">Optional condition.</param>
        public static void MapPropertiesTo(this object source, object destination, MappingFlags flags = MappingFlags.NoReferenceTypes, Func<PropertyInfo, bool> condition = null)
        {
            foreach (var prop in source.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                var propType = prop.PropertyType;
                var value = prop.GetValue(source);

                if (condition != null)
                {
                    if (!condition(prop)) continue;
                }

                if (!propType.IsValueType && flags.HasFlag(MappingFlags.ValueTypesOnly))
                {
                    continue;
                }

                if (propType == typeof(String) && flags.HasFlag(MappingFlags.NoStrings))
                {
                    continue;
                }

                if (propType.IsClass && propType != typeof(String) && flags.HasFlag(MappingFlags.NoReferenceTypes))
                {
                    continue;
                }

                if (flags.HasFlag(MappingFlags.NoNullStrings) && propType == typeof(String) && String.IsNullOrEmpty(value as String))
                {
                    continue;
                }

                var desProp = destination.GetType().GetProperty(prop.Name, BindingFlags.Public | BindingFlags.Instance);

                if (desProp != null && desProp.SetMethod != null && desProp.PropertyType.IsEnum && prop.PropertyType.IsEnum)
                {
                    desProp.SetValue(destination, Enum.Parse(desProp.PropertyType, value.ToString()));
                }
                else if (desProp != null && desProp.PropertyType == prop.PropertyType && desProp.SetMethod != null)
                {
                    desProp.SetValue(destination, value);
                }
            }
        }


        /// <summary>
        /// Maps the object primitive properties values to the destination object.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="destination">The destination.</param>
        public static void MapPrimitivesTo(this object source, object destination)
        {
            source.MapPropertiesTo(destination, MappingFlags.ValueTypesOnly);
        }

        /// <summary>
        /// Serializes the specified object to indented json string.
        /// </summary>
        /// <param name="obj">The object.</param>
        /// <returns></returns>
        public static String ToJsonString(this Object obj)
        {
            if (obj == null) return "null";

            if (!_jsonSettingsSet)
            {
                JsonConvert.DefaultSettings = (() =>
                {
                    var settings = new JsonSerializerSettings();
                    settings.Converters.Add(new StringEnumConverter { CamelCaseText = false });
                    settings.ContractResolver = new ProtobufContractResolver();
                    return settings;
                });

                _jsonSettingsSet = true;
            }

            return JsonConvert.SerializeObject(obj, Formatting.Indented);
        }

        /// <summary>
        /// Serializes the specified object to indented json string.
        /// </summary>
        /// <param name="obj">The object.</param>
        /// <returns></returns>
        public static String ToJsonString(this Object obj, params String[] ignoreProperties)
        {
            var settings = new JsonSerializerSettings() { ContractResolver = new DynamicContractResolver(ignoreProperties) };
            settings.Converters.Add(new StringEnumConverter { CamelCaseText = false });
            return JsonConvert.SerializeObject(obj, Formatting.Indented, settings);
        }

        /// <summary>
        /// Serializes the specified object to indented json html string.
        /// </summary>
        /// <param name="obj">The object.</param>
        /// <returns></returns>
        public static String ToHtmlJsonString(this Object obj, params String[] ignoreProperties)
        {
            var settings = new JsonSerializerSettings() { ContractResolver = new HtmlContractResolver(ignoreProperties) };
            settings.Converters.Add(new StringEnumConverter { CamelCaseText = false });
            return JsonConvert.SerializeObject(obj, Formatting.Indented, settings);
        }

        /// <summary>
        /// Gets the property value by the specified path (e.g DateTime.Date.Days).
        /// </summary>
        /// <param name="obj">The object.</param>
        /// <param name="propertyPath">The property path.</param>
        /// <returns></returns>
        public static Object GetPropertyValueByPath(this object obj, String propertyPath)
        {
            if (propertyPath != null)
            {
                if (propertyPath.Contains('.'))
                {
                    string[] Split = propertyPath.Split('.');
                    string RemainingProperty = propertyPath.Substring(propertyPath.IndexOf('.') + 1);
                    return GetPropertyValueByPath(obj.GetType().GetProperty(Split[0]).GetValue(obj, null), RemainingProperty);
                }
                else
                {
                    var prop = obj.GetType().GetProperty(propertyPath);

                    if (prop != null)
                    {
                        return prop.GetValue(obj, null);
                    }
                    else
                    {
                        return obj.ToString();
                    }
                }
            }
            else
            {
                return obj.ToString();
            }
        }

        /// <summary>
        /// Sets the property value by the specified path (e.g DateTime.Date.Days).
        /// </summary>
        /// <param name="obj">The object.</param>
        /// <param name="propertyPath">The property path.</param>
        /// <returns></returns>
        public static void SetPropertyValueByPath(this object obj, String propertyPath, object value)
        {
            if (propertyPath != null)
            {
                if (propertyPath.Contains('.'))
                {
                    string[] Split = propertyPath.Split('.');
                    string RemainingProperty = propertyPath.Substring(propertyPath.IndexOf('.') + 1);
                    SetPropertyValueByPath(obj.GetType().GetProperty(Split[0]).GetValue(obj, null), RemainingProperty, value);
                }
                else
                {
                    obj.GetType().GetProperty(propertyPath).SetValue(obj, value);
                }
            }
        }
    }
}