using System;

using System.Collections.Generic;

using System.Text;

using System.IO;

using System.Linq;

using System.Reflection;

using SuperSocket.ClientEngine;

#if !NETFX_CORE

using System.Security.Cryptography;

#else

using Windows.Security.Cryptography;

using Windows.Security.Cryptography.Core;

#endif

namespace WebSocket4Net

{

public static partial class Extensions

{

private readonly static char[] m_CrCf = new char[] { '\r', '\n' };

public static void AppendFormatWithCrCf(this StringBuilder builder, string format, object arg)

{

builder.AppendFormat(format, arg);

builder.Append(m_CrCf);

}

public static void AppendFormatWithCrCf(this StringBuilder builder, string format, params object[] args)

{

builder.AppendFormat(format, args);

builder.Append(m_CrCf);

}

public static void AppendWithCrCf(this StringBuilder builder, string content)

{

builder.Append(content);

builder.Append(m_CrCf);

}

public static void AppendWithCrCf(this StringBuilder builder)

{

builder.Append(m_CrCf);

}

private const string m_Tab = "\t";

private const char m_Colon = ':';

private const string m_Space = " ";

private const string m_ValueSeparator = ", ";

public static bool ParseMimeHeader(this string source, IDictionary<string, object> valueContainer, out string verbLine)

{

verbLine = string.Empty;

var items = valueContainer;

string line;

string prevKey = string.Empty;

var reader = new StringReader(source);

while (!string.IsNullOrEmpty(line = reader.ReadLine()))

{

if (string.IsNullOrEmpty(verbLine))

{

verbLine = line;

continue;

}

object currentValue;

if (line.StartsWith(m_Tab) && !string.IsNullOrEmpty(prevKey))

{

if (!items.TryGetValue(prevKey, out currentValue))

return false;

items[prevKey] = currentValue + line.Trim();

continue;

}

int pos = line.IndexOf(m_Colon);

if (pos < 0)

continue;

string key = line.Substring(0, pos);

if (!string.IsNullOrEmpty(key))

key = key.Trim();

string value = line.Substring(pos + 1);

if (!string.IsNullOrEmpty(value) && value.StartsWith(m_Space) && value.Length > 1)

value = value.Substring(1);

if (string.IsNullOrEmpty(key))

continue;

if (!items.TryGetValue(key, out currentValue))

{

items.Add(key, value);

}

else

{

items[key] = currentValue + m_ValueSeparator + value;

}

prevKey = key;

}

return true;

}

public static TValue GetValue<TValue>(this IDictionary<string, object> valueContainer, string name)

{

var defaultValue = default(TValue);

return GetValue(valueContainer, name, defaultValue);

}

public static TValue GetValue<TValue>(this IDictionary<string, object> valueContainer, string name, TValue defaultValue)

{

object value;

if (!valueContainer.TryGetValue(name, out value))

return defaultValue;

return (TValue)value;

}

private static Type[] m_SimpleTypes = new Type[] {

typeof(String),

typeof(Decimal),

typeof(DateTime),

typeof(DateTimeOffset),

typeof(TimeSpan),

typeof(Guid)

};

internal static bool IsSimpleType(this Type type)

{

#if NETFX_CORE || NETCORE

var typeInfo = type.GetTypeInfo();

return

typeInfo.IsValueType ||

typeInfo.IsPrimitive ||

m_SimpleTypes.Contains(type) ||

Convert.GetTypeCode(type) != TypeCode.Object;

#else

return

type.IsValueType ||

type.IsPrimitive ||

m_SimpleTypes.Contains(type) ||

Convert.GetTypeCode(type) != TypeCode.Object;

#endif

}

public static string GetOrigin(this Uri uri)

{

#if NETFX_CORE || NETCORE

return uri.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped);

#else

return uri.GetLeftPart(UriPartial.Authority);

#endif

}

public static byte[] ComputeMD5Hash(this byte[] source)

{

#if NETFX_CORE

var algProv = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);

var hash = algProv.CreateHash();

hash.Append(CryptographicBuffer.CreateFromByteArray(source));

byte[] result;

CryptographicBuffer.CopyToByteArray(hash.GetValueAndReset(), out result);

return result;

#else

return MD5.Create().ComputeHash(source);

#endif

}

public static string CalculateChallenge(this string source)

{

#if NETFX_CORE

var algProv = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);

var hash = algProv.CreateHash();

hash.Append(CryptographicBuffer.ConvertStringToBinary(source, BinaryStringEncoding.Utf8));

return CryptographicBuffer.EncodeToBase64String(hash.GetValueAndReset());

#elif !SILVERLIGHT

return Convert.ToBase64String(SHA1.Create().ComputeHash(Encoding.ASCII.GetBytes(source)));

#else

return Convert.ToBase64String(SHA1.Create().ComputeHash(ASCIIEncoding.Instance.GetBytes(source)));

#endif

}

}

}