using System.Text;
using System.IO.Compression;
using System.Globalization;
using System.Diagnostics;
using MarketData.MarketDataModel;

namespace MarketData.Utils
{
  public class Utility
  {
    private static DateTime epoch = DateTime.Parse("01-01-0001");
    private static TimeSpan oneDay=new TimeSpan(1,0,0,0);
    private static readonly System.Globalization.CultureInfo cultureInfo = new System.Globalization.CultureInfo("en-US");
    private static readonly String[] formats = new[] {"dddd, MMMM dd","MMM dd yyyy","yyyy-MM","ddd, MMM. d","ddd, MMM. dd", "yyyy/MM/dd","M-d-yyyy", "dd-MM-yyyy", "MM-dd-yyyy", "M.d.yyyy", "dd.MM.yyyy", "MM.dd.yyyy","yyyyMMdd" }.Union(cultureInfo.DateTimeFormat.GetAllDateTimePatterns()).ToArray();

    public static String ToUrl(String prefix, String ipAddress, String postfix)
    {
      return prefix + ipAddress + postfix;
    }

    public static String Pad(string str, char filler, int length)
    {
      int stringLength = str.Length;
      if (stringLength >= length) return str;
      StringBuilder sb = new StringBuilder();
      while (stringLength < length)
      {
        sb.Append(filler);                                            
        stringLength++;
      }
      return sb.ToString() + str;
    }
    public static String RemoveHtml(String strItem)
    {
      String[] codes = { "&#x27;","&#187;" };
      if(null==strItem)return strItem;
      foreach (String code in codes)
      {
        strItem = strItem.Replace(code,"'");
      }
      return strItem;
//      String str=strItem.Replace("&#x27;","'");
 //     return str;
    }
    public static String RemoveDivs(String strItem)
    {
      StringBuilder sb=new StringBuilder();
      bool inDiv=false;
      if(null==strItem)return strItem;
      for(int index=0;index<strItem.Length;index++)
      {
        char ch=strItem[index];
        if(ch.Equals('<'))inDiv=true;
        else if(ch.Equals('>'))inDiv=false;
        else if(!inDiv)sb.Append(ch);
      }
      return sb.ToString();
    }
    public static String BetweenString(String strItem, String strBegin, String strEnd)
    {
      if (null == strItem) return null;
      int index=-1;
      if(null==strBegin)index=0;
      else index = strItem.IndexOf(strBegin);
      if (-1 == index) return null;
      String str = null;
      if(null!=strBegin)str=strItem.Substring(index + strBegin.Length);
      else str=strItem;
      if(null==strEnd)return str;
      index = str.IndexOf(strEnd);
      if (-1 == index) return null;
      StringBuilder sb = new StringBuilder();
      for (int strIndex = 0; strIndex < str.Length; strIndex++)
      {
        if (index == strIndex) break;
        sb.Append(str[strIndex]);
      }
      return sb.ToString();
    }
    public static String RemoveAfter(String strItem, char charItem)
    {
      StringBuilder sb = new StringBuilder();
      for (int index = 0; index < strItem.Length; index++)
      {
        char ch = strItem[index];
        if (ch.Equals(charItem)) break;
        sb.Append(ch);
      }
      return sb.ToString();
    }
    public static bool OutOfRange(double value)
    {
      return value > 100000000000000000000.00 || value< -99999999999999999999.99;
    }
    public static String RemoveControlChars(String strItem)
    {
      StringBuilder sb=new StringBuilder();
      for(int index=0;index<strItem.Length;index++)
      {
        char ch=strItem[index];
        if(!char.IsControl(ch))sb.Append(ch);
      }
      return sb.ToString();
    }
    public static String GetPath(String strPathFileName)
    {
      int index=strPathFileName.LastIndexOf('\\');
      if (-1 == index) return null;
      String strPath = strPathFileName.Substring(0, index);
      return strPath;
    }
    public static String KeepBefore(String strItem,String strKeepBefore)
    {
      int startPos=strItem.IndexOf(strKeepBefore);
      if(-1==startPos)return null;
      return strItem.Substring(0,startPos);
    }
    public static String KeepAfter(String strItem,String strKeepAfter)
    {
      int startPos=strItem.IndexOf(strKeepAfter);
      if(-1==startPos)return null;
      return strItem.Substring(startPos+strKeepAfter.Length);
    }
    public static String KeepAfterLast(String strItem,String strKeepAfter)
    {
      if(null==strItem)return null;
      int startPos=strItem.LastIndexOf(strKeepAfter);
      if(-1==startPos)return null;
      return strItem.Substring(startPos+strKeepAfter.Length);
    }
    public static String Find(String strItem,String search,char delimeter)
    {
      if(null==strItem)return null;
      bool foundDelimeter=false;
      StringBuilder sb=new StringBuilder();
      int startPos=strItem.LastIndexOf(search);
      if(-1==startPos)return null;
      startPos+=search.Length;
      for(;startPos<strItem.Length;startPos++)
      {
        char ch=strItem[startPos];
        if(ch.Equals(delimeter))
        {
          foundDelimeter=true;
          break;
        }
        sb.Append(ch);
      }
      if(!foundDelimeter)return null;
      return sb.ToString();
    }
    public static String FindFirst(String strItem,String search,char delimeter)
    {
      if(null==strItem)return null;
      bool foundDelimeter=false;
      StringBuilder sb=new StringBuilder();
      int startPos=strItem.IndexOf(search);
      if(-1==startPos)return null;
      startPos+=search.Length;
      for(;startPos<strItem.Length;startPos++)
      {
        char ch=strItem[startPos];
        if(ch.Equals(delimeter))
        {
          foundDelimeter=true;
          break;
        }
        sb.Append(ch);
      }
      if(!foundDelimeter)return null;
      return sb.ToString();
    }
    public static String AddQuotes(String item)
    {
      return "\"" + item + "\"";
    }
    public static long DateToLong(DateTime date)
    {
      int year = date.Year;
      int month = date.Month;
      int day = date.Day;
      return (year * 10000) + (month * 100) + day;
    }
    public static DateTime LongToDate(long longDate)
    {
      int year = (int)(longDate / 10000);
      int month = ((int)longDate / 100) - year * 100;
      int day = (int)(longDate - ((int)(longDate / 100)) * 100);
      return new DateTime(year, month, day);
    }
    public static String DateTimeToStringHHMMSS(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("HH:mm:ss");
    }
    public static String DateTimeToStringHHMMSSTT(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("HH:mm:ss tt");
    }    
    public static String DateTimeToStringMMSDDSYYYY(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("MM/dd/yyyy");
    }
    public static String DateTimeToStringMMSYYYY(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("MM/yyyy");
    }
    public static String DateTimeToStringMMSYY(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("MM/yy");
    }
    public static String DateTimeToStringMMSDDSYYYYHHMMSS(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("MM/dd/yyyy hh:mm:ss");
    }
    public static String DateTimeToStringMMHDDHYYYY(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("MM-dd-yyyy");
    }
    public static String DateTimeToStringYYYYHMMHDD(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("yyyy-MM-dd");
    }
    public static String DateTimeToStringYYYYHMMHDDHHMMSS(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("yyyy-MM-dd HH:MM:ss");
    }
    public static String DateTimeToStringYYYYMMDD(DateTime dateTime)
    {
      if (Utility.IsEpoch(dateTime)) return "";
      return dateTime.ToString("yyyyMMdd");
    }
    public static String AsteriskForString(String str)
    {
      StringBuilder sb = new StringBuilder();
      int length = str.Length;
      for (int index = 0; index < length; index++) sb.Append("*");
      return sb.ToString();
    }
    public static String FormatNumber(double number)
    {
      StringBuilder sb=new StringBuilder();
      if (double.NaN.Equals(number))sb.Append("N/A");
      else sb.Append(String.Format("{0:0.000}", number));
      return sb.ToString();
    }

    public static String FormatNumberConstrain(double value,int places=1,bool commas=false)
    {
      String strValue=null;
      if(value>=1000)
      {
        value/=1000;
        strValue=Utility.FormatNumber(value,places,commas)+"K";
      }
      else if(value>=1000000)
      {
        value/=1000000;
        strValue=Utility.FormatNumber(value,places,commas)+"M";
      }
      else if(value>=1000000000)
      {
        value/=1000000000;
        strValue=Utility.FormatNumber(value,places,commas)+"B";
      }
      else
      {
        strValue=Utility.FormatNumber(value,places,commas);
      }
      return strValue;
    }
    public static String FormatNumber(double number,int places,bool commas=false)
    {
      StringBuilder sb = new StringBuilder();

      StringBuilder formatString=new StringBuilder();
      if (commas&&number>=1000.00) formatString.Append("{0:0,0.");
      else formatString.Append("{0:0.");
      for(int index=0;index<places;index++)formatString.Append("0");
      formatString.Append("}");
      if (double.NaN.Equals(number)) sb.Append("N/A");
      else sb.Append(String.Format(formatString.ToString(), number));
      return sb.ToString();
    }
    public static String FormatCurrency(double number)
    {
      StringBuilder sb = new StringBuilder();
      if (double.NaN.Equals(number)) sb.Append("N/A");
      else sb.Append(String.Format("{0:C}", number));
      return Reformat(sb.ToString(), number) ;
    }

    public static String FormatCurrency(double number,int decimals)
    {
      StringBuilder sb=new StringBuilder();
      String currencyFormat="{0:C"+decimals+"}";
      if (double.NaN.Equals(number))sb.Append("N/A");
      else sb.Append(String.Format(currencyFormat, number));
      return Reformat(sb.ToString(), number);
    }

    // This is a workaround for ARM64 architecture where the leading and trailing parens are omitted for negative numbers
    private static String Reformat(String str, double number)
    {
      if (String.IsNullOrEmpty(str)) return str;
      if (number < 0.00 && !str.StartsWith("("))
      {
        return "(" + str + ")";
      }
      return str;
    }
    
    public static String FormatPercent(double number)
    {
      StringBuilder sb = new StringBuilder();
      if (double.NaN.Equals(number)) sb.Append("N/A");
      else sb.Append(String.Format("{0:P}", number));
      return sb.ToString();
    }
    public static String FormatPercent(double number,int places)
    {
      String formatString = "{0:P" +places.ToString() + "}";
      StringBuilder sb = new StringBuilder();
      if (double.NaN.Equals(number)) sb.Append("N/A");
      else sb.Append(String.Format(formatString, number));
      return sb.ToString();
    }    
    public static String ConformDate(String strDate)
    {
      String[] elements=strDate.Split(' ');
      if(elements.Length<3)return strDate;
      return elements[0]+" "+elements[1]+" "+elements[2];
    }
    public static DateTime ParseDate(String strDate)
    {
      strDate = strDate.Trim();
      DateTime dateTime=DateTime.ParseExact(strDate, formats, cultureInfo, DateTimeStyles.AssumeLocal);
      return dateTime;
    }
    public static double ParsePercent(String strPercent)
    {
      if (null == strPercent) return double.NaN;
      strPercent = strPercent.Replace("%", null);
      try { return double.Parse(strPercent)/100.00; }
      catch (Exception) { return double.NaN; }
    }
    public static double ParseCurrency(String strNumber)
    {
      if (null == strNumber) return double.NaN;
      if(Constants.CONST_DASHES.Equals(strNumber))return double.NaN;
      strNumber = strNumber.Replace("$", null);
      strNumber = strNumber.Replace(",", null);
      strNumber = strNumber.Replace("(", "-");
      strNumber = strNumber.Replace(")", null);
      if (strNumber.Equals("")) return double.NaN;
      try { return double.Parse(strNumber); }
      catch (Exception) { return double.NaN; }
    }
    public static String FormatCurrencyWithQuotes(double number)
    {
      return AddQuotes(FormatCurrency(number));
    }
    public static String FormatDates(DateTime d1, DateTime d2)
    {
      StringBuilder sb=new StringBuilder();
      sb.Append(Utility.DateTimeToStringMMSDDSYYYY(d1)).Append("-");
      sb.Append(Utility.DateTimeToStringMMSDDSYYYY(d2));
      return sb.ToString();
    }
    public static String TrimToSpace(String strString)
    {
      if (null == strString) return strString;
      StringBuilder sb = new StringBuilder();
      for (int index = 0; index < strString.Length; index++)
      {
        char ch=strString[index];
        if (' '.Equals(ch)) break;
        sb.Append(ch);
      }
      return sb.ToString();
    }
    public static String BooleanToYesNoString(bool booleanValue)
    {
      return booleanValue ? "Yes" : "No";
    }
    public static bool IsEpoch(DateTime dateTime)
    {
      return dateTime.Equals(epoch);
    }
    public static DateTime Epoch
    {
      get { return epoch; }
    }
    public static TimeSpan OneDay
    {
      get{return oneDay;}
    }
    public static String ListToString(List<String> list,char separator=',')
    {
      StringBuilder sb=new StringBuilder();
      if (null == list || 0 == list.Count) return null;
      for(int index=0;index<list.Count;index++)
      {
        sb.Append(list[index]);
        if(index<list.Count-1)sb.Append(separator);
      }
      return sb.ToString();
    }
    public static List<String> ToList(String items,char separator=',')
    {
      List<String> list = items.Split(separator).ToList<String>();
      list=(from String s in list select s.Trim()).ToList<String>();
      return list;
    }
    public static String FromList(List<String> items,String postFix=",")
    {
      StringBuilder sb=new StringBuilder();
      for(int index=0;index<items.Count;index++)
      {
        sb.Append(items[index]);
        if(index<items.Count-1)sb.Append(postFix);
      }
      return sb.ToString();
    }
    public static byte[] Compress(String strString)
    {
      MemoryStream outputStream = null;
      GZipStream compressionStream = null;
      try
      {
        byte[] bytes = System.Text.Encoding.UTF8.GetBytes(strString);
        outputStream = new MemoryStream();
        compressionStream = new GZipStream(outputStream, CompressionMode.Compress, true);
        compressionStream.Write(bytes, 0, bytes.Length);
        compressionStream.Close();
        compressionStream = null;
        byte[] outputBytes = outputStream.ToArray();
        outputStream.Close();
        outputStream = null;
        return outputBytes;
      }
      catch (Exception exception)
      {
        MDTrace.WriteLine(LogLevel.DEBUG,exception);
        return null;
      }
      finally
      {
        if (null != compressionStream)
        {
          compressionStream.Close();
          compressionStream = null;
        }
        if (null != outputStream)
        {
          outputStream.Close();
          outputStream = null;
        }
      }
    }
    public static String Decompress(byte[] compressedBytes)
    {
      MemoryStream compressedStream = new MemoryStream(compressedBytes);
      GZipStream decompressionStream = new GZipStream(compressedStream, CompressionMode.Decompress,true);
      MemoryStream outputStream=new MemoryStream();
      try
      {
        byte[] decompressedBytesBuffer = new byte[4096];
        int count = 0;
        while (true)
        {
          count = decompressionStream.Read(decompressedBytesBuffer, 0, decompressedBytesBuffer.Length);
          if (count > 0) outputStream.Write(decompressedBytesBuffer, 0, count);
          else break;
        }
        decompressionStream.Close();
        compressedStream.Close();
        String strDecompressed = System.Text.Encoding.UTF8.GetString(outputStream.ToArray());
        outputStream.Close();
        outputStream = null;
        compressedStream = null;
        decompressionStream = null;
        return strDecompressed;
      }
      catch (Exception exception)
      {
        MDTrace.WriteLine(LogLevel.DEBUG,exception);
        return null;
      }
      finally
      {
        if (null != outputStream)
        {
          outputStream.Close();
          outputStream = null;
        }
        if (null != decompressionStream)
        {
          decompressionStream.Close();
          decompressionStream = null;
        }
        if (null != compressedStream)
        {
          compressedStream.Close();
          compressedStream = null;
        }
      }
    }
    public static void LaunchBrowserSearch(String searchTerm)
    {
      Process.Start("https://www.google.com/search?q="+Uri.EscapeDataString(searchTerm)+"/");
//      OpenWebCommand = new Command(async () => await Browser.OpenAsync("https://www.google.com"));
    }
    public static bool IsZeroOrNaN(double value)
    {
      return IsNaN(value)||IsZero(value);
    }
    private static bool IsZero(double value)
    {
      if(value==0.00)return true;
      return false;
    }
    private static bool IsNaN(double value)
    {
      return double.IsNaN(value);
    }
    public static void DeleteFile(String pathFileName)
    {
      if(!File.Exists(pathFileName))return;
      try{File.Delete(pathFileName);}catch(Exception){;}
    }
    private static DateTime GetRunDate(String strPathFileName)
    {
      DateTime runDate=DateTime.Now.Date;
      DateGenerator dateGenerator=new DateGenerator();
      StreamWriter streamWriter=null;
      StreamReader streamReader=null;

      try
      {
        if(!File.Exists(strPathFileName))
        {
          streamWriter=File.CreateText(strPathFileName);
          streamWriter.WriteLine(Utility.DateTimeToStringMMHDDHYYYY(runDate));
          streamWriter.Flush();
          streamWriter.Close();
          streamWriter=null;
          return runDate;
        }
        streamReader=File.OpenText(strPathFileName);
        String strLine=streamReader.ReadLine();
        streamReader.Close();
        streamReader=null;
        runDate=Utility.ParseDate(strLine);
        if(dateGenerator.DaysBetweenActual(runDate,DateTime.Now)>5)
        {
          File.Delete(strPathFileName);
          runDate=DateTime.Now.Date;
          streamWriter=File.CreateText(strPathFileName);
          streamWriter.WriteLine(Utility.DateTimeToStringMMHDDHYYYY(runDate));
          streamWriter.Flush();
          streamWriter.Close();
          streamWriter=null;
          return runDate;
        }
        return runDate;
      }
      catch(Exception exception)
      {
        MDTrace.WriteLine(LogLevel.DEBUG,String.Format("GetRunDate:{0}",exception.ToString()));
        return runDate;
      }
      finally
      {
        if(null!=streamWriter)streamWriter.Close();
        if(null!=streamReader)streamReader.Close();
      }
    }
  }
}