using System;
using System.Text;
using System.Net.NetworkInformation;
using System.Data;
using DTS.Common.Utilities.Logging;
using System.Collections.Generic;

namespace DTS.Common.Classes
{
    /// <summary>
    /// The Utility class.
    /// </summary>
    /// 
    public sealed class Utility
    {
        public static byte[] GetBytesFromStringArray(string[] array, string separator)
        {
            var text = string.Join(separator, array);
            return Encoding.UTF8.GetBytes(text);
        }
        /// <summary>
        /// Returns all error messages include inner exceptions' messages.
        /// </summary>
        /// <param name="ex">The System.Exception object.</param>
        /// <returns>Returns all error messages as a string.</returns>
        public static string GetAllErrorMessages(Exception ex)
        {
            if (ex == null)
                return string.Empty;

            // assign the current exception as first object 
            // and then loop through its inner exceptions till they are null

            var sb = new StringBuilder();
            sb.AppendLine("Error Message: " + ex.Message);

            var innerEx = ex;
            while (innerEx.InnerException != null)
            {
                innerEx = innerEx.InnerException;
                sb.AppendLine("Inner Exception: " + innerEx.Message);
            }

            return sb.ToString();
        }

        /// <summary>
        /// Check internet connection availability
        /// </summary>
        /// <param name="hostNameOrAddress">The host name ar address.</param>
        /// <returns><c>true</c> if internet connection available; otherwise, <c>false</c>.</returns>
        public static bool PingNetwork(string hostNameOrAddress)
        {
            bool pingStatus;

            using (var p = new Ping())
            {
                var buffer = Encoding.ASCII.GetBytes("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
                const int timeout = 4444; // 4s

                try
                {
                    var reply = p.Send(hostNameOrAddress, timeout, buffer);
                    pingStatus = (reply.Status == IPStatus.Success);
                }
                catch (Exception)
                {
                    pingStatus = false;
                }
            }

            return pingStatus;
        }
        public static ushort GetUShort(IDataReader reader, string column, ushort defaultValue = 0)
        {
            if (string.IsNullOrWhiteSpace(column)) { return defaultValue; }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }
            try
            {
                return Convert.ToUInt16(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse string for field {column}", o, ex);
                return defaultValue;
            }
        }
        public static uint GetUInt(IDataReader reader, string column, uint defaultValue = 0)
        {
            if (string.IsNullOrWhiteSpace(column)) { return defaultValue; }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }
            try
            {
                return Convert.ToUInt32(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse string for field {column}", o, ex);
                return defaultValue;
            }
        }
        public static string GetString(IDataReader reader, string column, string defaultValue = "")
        {
            if (string.IsNullOrWhiteSpace(column)) { return defaultValue; }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }
            try
            {
                return Convert.ToString(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse string for field {column}", o, ex);
                return defaultValue;
            }
        }

        public static string[] GetStringArray(IDataReader reader,
            string column,
            string[] defaultValue,
            string separator)
        {
            try
            {
                var o = reader[column];
                if (DBNull.Value.Equals(o)) { return defaultValue; }
                var bytes = (byte[])o;
                var text = Encoding.UTF8.GetString(bytes);
                var values = text.Split(new[] { separator }, StringSplitOptions.None);
                return values;
            }
            catch (Exception ex)
            {
                APILogger.Log(ex);
                return defaultValue;
            }
        }
        public static int GetInt(IDataReader reader, string column, int defaultValue = 0)
        {
            if (string.IsNullOrWhiteSpace(column))
            {
                return defaultValue;
            }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }

            try
            {
                return Convert.ToInt32(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse int for field {column}", o, ex);
                return defaultValue;
            }
        }
        public static double GetDouble(IDataReader reader, string column, double defaultValue = 0D)
        {
            if (string.IsNullOrWhiteSpace(column))
            {
                return defaultValue;
            }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }

            try
            {
                return Convert.ToDouble(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse double for field {column}", o, ex);
                return defaultValue;
            }
        }
        public static short GetShort(IDataReader reader, string column, short defaultValue = 0)
        {
            if (string.IsNullOrWhiteSpace(column))
            {
                return defaultValue;
            }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }

            try
            {
                return Convert.ToInt16(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse double for field {column}", o, ex);
                return defaultValue;
            }
        }
        public static DateTime? GetNullableDateTime(IDataReader reader, string column)
        {
            if (string.IsNullOrWhiteSpace(column)) { return null; }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return null;
            }
            return Convert.ToDateTime(o);
        }
        public static ulong GetUlong(IDataReader reader, string column, ulong defaultValue = 0)
        {
            if (string.IsNullOrWhiteSpace(column)) { return defaultValue; }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }
            return Convert.ToUInt64(o);
        }
        public static int? GetNullableInt(IDataReader reader, string column)
        {
            if (string.IsNullOrWhiteSpace(column)) { return null; }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return null;
            }
            return Convert.ToInt32(o);
        }
        public static byte[] GetByteArray(IDataReader reader, string column)
        {
            if (string.IsNullOrWhiteSpace(column))
            {
                return new byte[0];
            }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return new byte[0];
            }
            return (byte[])reader[column];
        }
        public static bool GetBool(IDataReader reader, string column, bool defaultValue = false)
        {
            if (string.IsNullOrWhiteSpace(column))
            {
                return defaultValue;
            }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }

            try
            {
                return Convert.ToBoolean(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse bool for field {column}", o, ex);
                return defaultValue;
            }
        }
        public static DateTime GetDateTime(IDataReader reader, string column, DateTime defaultValue)
        {
            if (string.IsNullOrWhiteSpace(column))
            {
                return defaultValue;
            }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }

            try
            {
                return Convert.ToDateTime(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse DateTime for field {column}", o, ex);
                return defaultValue;
            }
        }
        public static long GetLong(IDataReader reader, string column, long defaultValue = 0)
        {
            if (string.IsNullOrWhiteSpace(column))
            {
                return defaultValue;
            }
            var o = reader[column];
            if (DBNull.Value.Equals(o))
            {
                return defaultValue;
            }

            try
            {
                return Convert.ToInt64(o);
            }
            catch (Exception ex)
            {
                APILogger.Log($"Failed to parse long for field {column}", o, ex);
                return defaultValue;
            }
        }
    }
}