using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Text;

namespace Sony.Filtr.Utility
{
    public static class Maybe
    {
        public static int? ToIntOrDefault(string s)
        {
            int parsed;
            if (int.TryParse(s, out parsed))
                return parsed;
            return null;
        }

        public static long? ToLongOrDefault(string s)
        {
            long parsed;
            if (long.TryParse(s, out parsed))
                return parsed;
            return null;
        }

        public static int ToIntOrFallback(string s, int fallback)
        {
            int parsed;

            if (int.TryParse(s, out parsed))
            {
                return parsed;
            }

            return fallback;
        }

        public static DateTime ToDateTimeOrFallback(string date, DateTime fallback)
        {
            DateTime tempdate;
            if (DateTime.TryParse(date, out tempdate))
                return tempdate;

            return fallback;
        }
        public static DateTime? ToDateTimeOrDefault(string date)
        {
            DateTime tempdate;
            if (DateTime.TryParse(date, out tempdate))
                return tempdate;

            return null;
        }

        public static TEnum? ToEnumOrDefault<TEnum>(string s) where TEnum : struct
        {
            TEnum parsed;
            const bool ignoreCase = true;
            if (Enum.TryParse<TEnum>(s, ignoreCase, out parsed))
                return parsed;
            return null;
        }

        public static bool? ToBoolOrDefault(string s)
        {
            bool booleanValue;
            if (bool.TryParse(s, out booleanValue))
            {
                return booleanValue;
            }
            return null;
        }

        public static bool ToBoolOrFallback(string s, bool fallback)
        {
            bool booleanValue;
            if (bool.TryParse(s, out booleanValue))
            {
                return booleanValue;
            }
            return fallback;
        }

        /// <summary>
        ///     High speed function for coverting list of string to quoted comma separated string.
        ///     Also using this function prevent from sql-injections because it cutout all spaces from the string
        ///     and makes a single string value as a result.
        ///     Example: from QWERTY,QWERTY1 to 'QWERTY','QWERTY1'.
        /// </summary>
        /// <param name="input">List of string to convert.</param>
        /// <returns>Returns qouted string which can be used in SQL query as param for IN operator.</returns>
        public static string ToCommaSeparated(IEnumerable<string> input)
        {
            if (input == null)
                return string.Empty;

            string[] array = input as string[];

            if (array == null)
                array = input.ToArray();

            var sb = new StringBuilder();

            for (int i = 0; i < array.Length; i++)
            {
                if(i == array.Length - 1)
                    sb.Append($"{ToSingleString(array[i])}");
                else
                    sb.Append($"{ToSingleString(array[i])},");
            }

            return ToCommaSeparated(sb.ToString());
        }

        /// <summary>
        ///     High speed function for coverting comma separated string to quoted comma separated.
        ///     Also using this function prevent from sql-injections because it cutout all spaces from the string
        ///     and makes a single string value as a result.
        ///     Example: from QWERTY,QWERTY1 to 'QWERTY','QWERTY1'.
        /// </summary>
        /// <param name="input">Input string to convert.</param>
        /// <returns>Returns qouted string which can be used in SQL query as param for IN operator.</returns>
        public static string ToCommaSeparated(string input)
        {
            char[] chars = input.ToCharArray();
            var sb = new StringBuilder();

            sb.Append("'");

            foreach (char val in chars)
            {
                if (val != ' ' && val != ',')
                    sb.Append(val);
                else if (val == ',')
                    sb.Append("','");
            }

            sb.Append("'");

            return sb.ToString();
        }

        /// <summary>
        ///     High speed function for removing spaces from string.
        ///     Also using this function prevent from sql-injections because it cutout all spaces from the string
        ///     and makes a single string value as a result.
        ///     Example: "select * from table" to "select*fromtable".
        /// </summary>
        /// <param name="input">Input string to convert.</param>
        /// <returns>Returns a single line string which can be used in SQL query as param.</returns>
        public static string ToSingleString(string input)
        {
            char[] chars = input.ToCharArray();
            var sb = new StringBuilder();

            foreach (char val in chars)
            {
                if (val != ' ')
                    sb.Append(val);
            }

            return sb.ToString();
        }

        public static IEnumerable<List<T>> SplitList<T>(List<T> largeList, int nSize = 30)
        {
            for (int i = 0; i < largeList.Count; i += nSize)
            {
                yield return largeList.GetRange(i, Math.Min(nSize, largeList.Count - i));
            }
        }

        public static IEnumerable<DateRange> ToDateRange(DateTime startDate, DateTime endDate, int groupDevider = 14)
        {
            var dateDiff = endDate.Subtract(startDate);
            bool needToDevide = dateDiff > TimeSpan.FromDays(groupDevider);

            var dates = new List<DateRange>();
            if (!needToDevide)
                dates.Add(new DateRange { From = startDate, To = endDate });
            else
            {
                int groups = Convert.ToInt32(Math.Round(dateDiff.TotalDays / groupDevider));
                var dateFrom = startDate;

                for (int i = 1; i <= groups; i++)
                {
                    int days = i * groupDevider;

                    var range = new DateRange { From = dateFrom };
                    if (i == groups)
                        range.To = endDate;
                    else
                        range.To = startDate.AddDays(days);

                    dateFrom = startDate.AddDays(days + 1);

                    dates.Add(range);
                }
            }

            return dates;
        }

        public static string AddLimitIfNeeded(string sql, int? offset, int? limit)
        {
            if (offset != null && limit != null)
            {
                sql += $" LIMIT {offset}, {limit}";
            }
            return sql;
        }
        
        public struct DateRange
        {
            public DateTime From { get; set; }
            public DateTime To { get; set; }

            public override string ToString()
            {
                return $"{From.ToShortDateString()} - {To.ToShortDateString()}";
            }
        }

        public static string GetStringNullCheck(this IDataReader reader, int ordinal)
        {
            return reader.IsDBNull(ordinal) ? String.Empty : reader.GetString(ordinal);
        }

        public static int? GetIntNullCheck(this IDataReader reader, int ordinal)
        {
            return reader.IsDBNull(ordinal) ? null as int? : reader.GetInt32(ordinal);
        }

        public static long? GetLongNullCheck(this IDataReader reader, int ordinal)
        {
            return reader.IsDBNull(ordinal) ? null as long? : reader.GetInt64(ordinal);
        }

        public static int GetAppSettingsIntOrDefault(string key, int defaultToReturn)
        {
            int number = defaultToReturn;
            if (Int32.TryParse(ConfigurationManager.AppSettings[key], out int result))
            {
                number = result;
            }

            return number;
        }

        public static bool GetAppSettingsBooleanOrDefault(string key, bool defaultToReturn)
        {
            bool toReturn = defaultToReturn;
            if (Boolean.TryParse(ConfigurationManager.AppSettings[key], out bool result))
            {
                toReturn = result;
            }

            return toReturn;
        }

        public static string GetAppSettingsStringOrDefault(string key, string defaultToReturn = "")
        {
            string value = ConfigurationManager.AppSettings[key];
            if (String.IsNullOrWhiteSpace(value))
            {
                value = defaultToReturn;
            }

            return value;
        }

        public static Nullable<DateTime> GetAppSettingsDateTimeOrDefault(string key, Nullable<DateTime> defaultToReturn = null)
        {
            string appSetting = ConfigurationManager.AppSettings[key];
            if (String.IsNullOrWhiteSpace(appSetting))
            {
                return defaultToReturn;
            }

            DateTime dt;
            return DateTime.TryParse(appSetting, out dt) ? dt : (Nullable<DateTime>)null;
        }
    }
}