using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Web.Script.Serialization;

namespace Json
{
    public class ConvertJson
    {
        private static string String2Json(string s)
        {
            StringBuilder stringBuilder = new StringBuilder();
            for (int index = 0; index < s.Length; ++index)
            {
                char ch = s.ToCharArray()[index];
                switch (ch)
                {
                    case '\b':
                        stringBuilder.Append("\\b");
                        break;
                    case '\t':
                        stringBuilder.Append("\\t");
                        break;
                    case '\n':
                        stringBuilder.Append("\\n");
                        break;
                    case '\f':
                        stringBuilder.Append("\\f");
                        break;
                    case '\r':
                        stringBuilder.Append("\\r");
                        break;
                    case '"':
                        stringBuilder.Append("\\\"");
                        break;
                    case '/':
                        stringBuilder.Append("\\/");
                        break;
                    case '\\':
                        stringBuilder.Append("\\\\");
                        break;
                    default:
                        stringBuilder.Append(ch);
                        break;
                }
            }
            return stringBuilder.ToString();
        }

        private static string StringFormat(string str, Type type)
        {
            if (type == typeof(string))
            {
                str = ConvertJson.String2Json(str);
                str = "\"" + str + "\"";
            }
            else if (type == typeof(DateTime))
                str = "\"" + str + "\"";
            else if (type == typeof(bool))
                str = str.ToLower();
            else if (type != typeof(string) && string.IsNullOrEmpty(str))
                str = "\"" + str + "\"";
            return str;
        }

        public static string ToJson(DataTable dt)
        {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.Append("[");
            DataRowCollection rows = dt.Rows;
            for (int index1 = 0; index1 < rows.Count; ++index1)
            {
                stringBuilder.Append("{");
                for (int index2 = 0; index2 < dt.Columns.Count; ++index2)
                {
                    string columnName = dt.Columns[index2].ColumnName;
                    string str1 = rows[index1][index2].ToString();
                    Type dataType = dt.Columns[index2].DataType;
                    stringBuilder.Append("\"" + columnName + "\":");
                    string str2 = ConvertJson.StringFormat(str1, dataType);
                    if (index2 < dt.Columns.Count - 1)
                        stringBuilder.Append(str2 + ",");
                    else
                        stringBuilder.Append(str2);
                }
                stringBuilder.Append("},");
            }
            stringBuilder.Remove(stringBuilder.Length - 1, 1);
            stringBuilder.Append("]");
            return stringBuilder.ToString();
        }

        public static DataTable JsonToTable(string Json) 
        {
            DataTable dt = new DataTable();
            DataTable result;
            try
            {
                JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
                javaScriptSerializer.MaxJsonLength = Int32.MaxValue;
                ArrayList arrayList = javaScriptSerializer.Deserialize<ArrayList>(Json);
                if (arrayList.Count > 0) 
                {
                    foreach (Dictionary<string,object > dictionary in arrayList) 
                    {
                        if (dictionary.Keys.Count == 0) 
                        {
                            result = dt;
                        }

                        if (dt.Columns.Count == 0) 
                        {
                            foreach (string current in dictionary.Keys) 
                            {
                                dt.Columns.Add(current, dictionary[current].GetType());
                            }
                        }
                        DataRow dataRow = dt.NewRow();
                        foreach (string current in dictionary.Keys) 
                        {
                            dataRow[current] = dictionary[current];
                        }

                        dt.Rows.Add(dataRow);
                    }

                }

            }
            catch 
            {
            }

            result = dt;
            return result;
        }

        public static string ToJson(DataTable dt, string jsonName)
        {
            StringBuilder stringBuilder = new StringBuilder();
            if (string.IsNullOrEmpty(jsonName))
                jsonName = dt.TableName;
            stringBuilder.Append("{\"" + jsonName + "\":[");
            if (dt.Rows.Count > 0)
            {
                for (int index1 = 0; index1 < dt.Rows.Count; ++index1)
                {
                    stringBuilder.Append("{");
                    for (int index2 = 0; index2 < dt.Columns.Count; ++index2)
                    {
                        Type type = dt.Rows[index1][index2].GetType();
                        stringBuilder.Append("\"" + dt.Columns[index2].ColumnName.ToString() + "\":" + ConvertJson.StringFormat(dt.Rows[index1][index2].ToString(), type));
                        if (index2 < dt.Columns.Count - 1)
                            stringBuilder.Append(",");
                    }
                    stringBuilder.Append("}");
                    if (index1 < dt.Rows.Count - 1)
                        stringBuilder.Append(",");
                }
            }
            stringBuilder.Append("]}");
            return stringBuilder.ToString();
        }

        public static string ToJson(DbDataReader dataReader)
        {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.Append("[");
            while (dataReader.Read())
            {
                stringBuilder.Append("{");
                for (int ordinal = 0; ordinal < dataReader.FieldCount; ++ordinal)
                {
                    Type fieldType = dataReader.GetFieldType(ordinal);
                    string name = dataReader.GetName(ordinal);
                    string str1 = dataReader[ordinal].ToString();
                    stringBuilder.Append("\"" + name + "\":");
                    string str2 = ConvertJson.StringFormat(str1, fieldType);
                    if (ordinal < dataReader.FieldCount - 1)
                        stringBuilder.Append(str2 + ",");
                    else
                        stringBuilder.Append(str2);
                }
                stringBuilder.Append("},");
            }
            dataReader.Close();
            stringBuilder.Remove(stringBuilder.Length - 1, 1);
            stringBuilder.Append("]");
            return stringBuilder.ToString();
        }

        public static string Serializer<T>(T t)
        {
            DataContractJsonSerializer contractJsonSerializer = new DataContractJsonSerializer(typeof(T));
            MemoryStream memoryStream = new MemoryStream();
            contractJsonSerializer.WriteObject((Stream)memoryStream, (object)t);
            string str = Encoding.UTF8.GetString(memoryStream.ToArray());
            memoryStream.Close();
            return str;
        }

        public static string SerializerForList<T>(List<T> list)
        {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.Append("[");
            foreach (T t in list)
                stringBuilder.AppendFormat("{0},", (object)ConvertJson.Serializer<T>(t));
            stringBuilder.Remove(stringBuilder.Length - 1, 1);
            stringBuilder.Append("]");
            return stringBuilder.ToString();
        }

        public static string SerializerForList1<T>(List<T> list)
        {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.Append("[");
            foreach (T t in list)
                stringBuilder.AppendFormat("{0},", (object)ConvertJson.Serializer<T>(t));
            stringBuilder.Remove(stringBuilder.Length - 1, 1);
            stringBuilder.Append("]");
            return stringBuilder.ToString();
        }

        public static T Deserialize<T>(string json)
        {
            return (T)new DataContractJsonSerializer(typeof(T)).ReadObject((Stream)new MemoryStream(Encoding.UTF8.GetBytes(json)));
        }

        public static string ToJson(object source)
        {
            return ConvertJson.ToJson(source, source.GetType());
        }

        public static string ToJson(object source, Type type)
        {
            using (Stream stream = (Stream)new MemoryStream())
            {
                new DataContractJsonSerializer(type).WriteObject(stream, source);
                stream.Flush();
                stream.Position = 0L;
                return new StreamReader(stream, Encoding.UTF8).ReadToEnd();
            }
        }

        public static string ListToJson<T>(T t, int totalCount)
        {
            return new JavaScriptSerializer().Serialize((object)new JsonShowModel<T>(totalCount, t));
        }

        public static string ListToJson<T>(T t)
        {
            return new JavaScriptSerializer().Serialize((object)t);
        }

        public static string ListToJson<T>(List<T> list)
        {
            return ConvertJson.ListToJson<List<T>>(list);
        }

        public static string ListToJson<T>(List<T> list, string jsonName)
        {
            if (string.IsNullOrEmpty(jsonName))
                jsonName = "d";
            return "{\"" + jsonName + "\":" + ConvertJson.ListToJson<T>(list) + "}";
        }

        public static T GetObjectJson<T>(string json)
        {
            return (T)new DataContractJsonSerializer(typeof(T)).ReadObject((Stream)new MemoryStream(Encoding.UTF8.GetBytes(json)));
        }

        public static object GetObjectJson(string json, Type type)
        {
            MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
            return new DataContractJsonSerializer(type).ReadObject((Stream)memoryStream);
        }

        public static DataTable ToDataTable(DataRow[] rows) 
        {
            try
            {
                if (rows == null || rows.Length == 0)
                {
                    return null;
                }

                DataTable dt = rows[0].Table.Clone();  
                foreach (DataRow row in rows)
                {
                    dt.Rows.Add(row.ItemArray); 
                }

                return dt;
            }
            catch (Exception)
            {
                return null;
            }

        }
    }
}