using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using CYQ.Data.Table;
using System.Data;
using System.Text.RegularExpressions;
using CYQ.Data.SQL;
using System.IO;
using System.Reflection;
using CYQ.Data.Xml;


namespace CYQ.Data.Tool
{
    /// <summary>
    /// Escape json char options
    /// <para>JsonHelper 的符号转义选项</para>
    /// </summary>
    public enum EscapeOp
    {
        /// <summary>
        /// 过滤ascii小于32的特殊值、并对\n "（双引号）进行转义，对\转义符 （仅\\"或\\n时不转义，其它情况转义）
        /// </summary>
        Default,
        /// <summary>
        ///  不进行任何转义，只用于保留原如数据（注意：存在双引号时，[或ascii小于32的值都会破坏json格式]，从而json数据无法被解析）
        /// </summary>
        No,
        /// <summary>
        ///  过滤ascii小于32的特殊值、并对 ：\r \n \t "（双引号） \(转义符号) 直接进行转义
        /// </summary>
        Yes,
        /// <summary>
        /// 系统内部使用： ascii小于32（包括\n \t \r）、"(双引号)，\(转义符号) 进行编码（规则为：@#{0}#@ {0}为asciii值，系统转的时候会自动解码）
        /// </summary>
        Encode
    }
    /// <summary>
    /// Json class for you easy to operate json
    /// <para>功能全面的json帮助类</para>
    /// </summary>
    public partial class JsonHelper
    {

        internal static EscapeOp DefaultEscape
        {
            get
            {
                return (EscapeOp)Enum.Parse(typeof(EscapeOp), AppConfig.JsonEscape);
            }
        }

        #region 实例属性

        public JsonHelper()
        {

        }
        /// <param name="addHead">with easyui header ?<para>是否带输出头</para></param>
        public JsonHelper(bool addHead)
        {
            _AddHead = addHead;
        }

        /// <param name="addSchema">first row with table schema ?
        /// <para>是否首行带表结构[MDataTable.LoadFromJson可以还原表的数据类型]</para></param>
        public JsonHelper(bool addHead, bool addSchema)
        {
            _AddHead = addHead;
            _AddSchema = addSchema;
        }
        #region 属性
        /// <summary>
        /// Escape options
        /// <para>转义符号</para>
        /// </summary>
        public EscapeOp Escape = JsonHelper.DefaultEscape;
        /// <summary>
        /// convert filed to lower
        /// <para>是否将名称转为小写</para>
        /// </summary>
        public bool IsConvertNameToLower = false;
        /// <summary>
        /// formate datetime
        /// <para>日期的格式化（默认：yyyy-MM-dd HH:mm:ss）</para>
        /// </summary>
        public string DateTimeFormatter = "yyyy-MM-dd HH:mm:ss";
        private const string brFlag = "[#<br>]";
        RowOp _RowOp = RowOp.IgnoreNull;
        /// <summary>
        ///  filter json data
        /// <para>Json输出行数据的过滤选项</para>
        /// </summary>
        public RowOp RowOp
        {
            get
            {
                return _RowOp;
            }
            set
            {
                _RowOp = value;
            }
        }
        //internal BreakOp BreakOp
        //{
        //    get
        //    {
        //        switch (_RowOp)
        //        {
        //            case Table.RowOp.IgnoreNull:
        //                return Table.BreakOp.Null;
        //            default:
        //                return Table.BreakOp.None;
        //        }
        //    }
        //}
        private bool _AddHead = false;
        private bool _AddSchema = false;
        /// <summary>
        ///  is success
        /// <para>是否成功</para>
        /// </summary>
        public bool Success
        {
            get
            {
                return rowCount > 0;
            }
        }
        private string errorMsg = "";
        /// <summary>
        /// Error message
        /// <para>错误提示信息  </para> 
        /// </summary>
        public string ErrorMsg
        {
            get
            {
                return errorMsg;
            }
            set
            {
                errorMsg = value;
            }
        }
        private int rowCount = 0;
        /// <summary>
        /// data rows count
        /// <para>当前返回的行数</para>
        /// </summary>
        public int RowCount
        {
            get
            {
                return rowCount;
            }
            set
            {
                rowCount = value;
            }
        }
        private int total;
        /// <summary>
        /// totla count
        /// <para>所有记录的总数（多数用于分页的记录总数）。</para>
        /// </summary>
        public int Total
        {
            get
            {
                if (total == 0)
                {
                    return rowCount;
                }
                return total;
            }
            set
            {
                total = value;
            }
        }
        #endregion

        private List<string> jsonItems = new List<string>();


        /// <summary>
        /// flag a json is end and start a new json
        /// <para> 添加完一个Json数据后调用此方法换行</para>
        /// </summary>
        public void AddBr()
        {
            jsonItems.Add(brFlag);
            rowCount++;
        }
        StringBuilder headText = new StringBuilder();
        StringBuilder footText = new StringBuilder();
        /// <summary>
        /// attach json data (AddHead must be true)
        /// <para>添加底部数据（只有AddHead为true情况才能添加数据）</para>
        /// </summary>
        public void AddFoot(string name, string value)
        {
            AddFoot(name, value, false);
        }

        public void AddFoot(string name, string value, bool noQuotes)
        {
            if (_AddHead)
            {
                footText.Append("," + Format(name, value, noQuotes));
            }
        }

        /// <summary>
        /// add json key value
        /// <para>添加一个字段的值</para>
        /// </summary>
        public void Add(string name, string value)
        {
            jsonItems.Add(Format(name, value, false));
        }

        /// <param name="noQuotes">value is no quotes
        /// <para>值不带引号</para></param>
        public void Add(string name, string value, bool noQuotes)
        {
            jsonItems.Add(Format(name, value, noQuotes));
        }
        public void Add(string name, object value)
        {
            if (value != null)
            {
                string v = null;
                Type t = value.GetType();
                if (t.IsEnum)
                {
                    value = (int)value;
                    Add(name, value.ToString(), true);
                }
                else
                {
                    int groupID = DataType.GetGroup(DataType.GetSqlType(t));
                    bool noQuotes = groupID == 1 || groupID == 3;
                    if (groupID == 999)
                    {
                        v = ToJson(value);
                    }
                    else
                    {
                        v = Convert.ToString(value);
                        if (groupID == 3)
                        {
                            v = v.ToLower();
                        }
                    }

                    Add(name, v, noQuotes);
                }
            }
            else
            {
                Add(name, "null", true);
            }
        }
        private string Format(string name, string value, bool children)
        {
            value = value ?? "";
            children = children && !string.IsNullOrEmpty(value);
            if (!children && value.Length > 1 &&
                ((value[0] == '{' && value[value.Length - 1] == '}') || (value[0] == '[' && value[value.Length - 1] == ']')))
            {
                children = IsJson(value);
            }
            if (!children)
            {
                SetEscape(ref value);
            }
            return "\"" + name + "\":" + (!children ? "\"" : "") + value + (!children ? "\"" : "");//;//.Replace("\",\"", "\" , \"").Replace("}{", "} {").Replace("},{", "}, {")
        }

        /// <summary>
        /// out json result
        /// <para>输出Json字符串</para>
        /// </summary>
        public override string ToString()
        {
            int capacity = 100;
            if (jsonItems.Count > 0)
            {
                capacity = jsonItems.Count * jsonItems[0].Length;
            }
            StringBuilder sb = new StringBuilder(capacity);

            if (_AddHead)
            {
                if (headText.Length == 0)
                {
                    sb.Append("{");
                    sb.Append("\"rowcount\":" + rowCount + ",");
                    sb.Append("\"total\":" + Total + ",");
                    sb.Append("\"errorMsg\":\"" + errorMsg + "\",");
                    sb.Append("\"success\":" + Success.ToString().ToLower() + ",");
                    sb.Append("\"rows\":");
                }
                else
                {
                    sb.Append(headText.ToString());
                }
            }
            if (jsonItems.Count == 0)
            {
                if (_AddHead)
                {
                    sb.Append("[]");
                }
            }
            else
            {
                if (jsonItems[jsonItems.Count - 1] != brFlag)
                {
                    AddBr();
                }
                if (_AddHead || rowCount > 1)
                {
                    sb.Append("[");
                }
                char left = '{', right = '}';
                if (jsonItems[0] != brFlag && !jsonItems[0].Contains(":"))
                {
                    //说明为数组
                    left = '[';
                    right = ']';
                }
                sb.Append(left);
                int index = 0;
                foreach (string val in jsonItems)
                {
                    index++;

                    if (val != brFlag)
                    {
                        sb.Append(val);
                        sb.Append(",");
                    }
                    else
                    {
                        if (sb[sb.Length - 1] == ',')
                        {
                            sb.Remove(sb.Length - 1, 1);//性能优化（内部时，必须多了一个“，”号）。
                            // sb = sb.Replace(",", "", sb.Length - 1, 1);
                        }
                        sb.Append(right + ",");
                        if (index < jsonItems.Count)
                        {
                            sb.Append(left);
                        }
                    }
                }
                if (sb[sb.Length - 1] == ',')
                {
                    sb.Remove(sb.Length - 1, 1);
                }
                //sb = sb.Replace(",", "", sb.Length - 1, 1);//去除最后一个,号。
                //sb.Append("}");
                if (_AddHead || rowCount > 1)
                {
                    sb.Append("]");
                }
            }
            if (_AddHead)
            {
                sb.Append(footText.ToString() + "}");
            }
            return sb.ToString();
            //string json = sb.ToString();
            //if (AppConfig.IsWeb && Escape == EscapeOp.Yes)
            //{
            //    json = json.Replace("\n", "<br/>");
            //}
            //if (Escape != EscapeOp.No) // Web应用
            //{
            //    json = json.Replace("\t", " ").Replace("\r", " ");
            //}
            //return json;

        }

        /// <param name="arrayEnd">end with [] ?</param>
        /// <returns></returns>
        public string ToString(bool arrayEnd)
        {
            string result = ToString();
            if (arrayEnd && !result.StartsWith("["))
            {
                result = '[' + result + ']';
            }
            return result;
        }

        #endregion

        /// <summary>
        /// check string is json
        /// <para>检测是否Json格式的字符串</para>
        /// </summary>
        public static bool IsJson(string json)
        {
            return JsonSplit.IsJson(json);
        }


        /// <param name="errIndex">the index of the error char
        /// <para>错误的字符索引</para></param>
        public static bool IsJson(string json, out int errIndex)
        {
            return JsonSplit.IsJson(json, out errIndex);
        }
        public static string GetValue(string json, string key)
        {
            return GetValue(json, key, DefaultEscape);
        }
        /// <summary>
        /// Get json value
        /// <para>获取Json字符串的值</para>
        /// </summary>
        /// <param name="key">the name or key of json
        /// <para>键值(有层级时用：XXX.YYY.ZZZ)</para></param>
        /// <returns></returns>
        public static string GetValue(string json, string key, EscapeOp op)
        {
            string value = GetSourceValue(json, key);
            return UnEscape(value, op);
        }

        private static string GetSourceValue(string json, string key)
        {
            string result = string.Empty;
            if (!string.IsNullOrEmpty(json))
            {
                List<Dictionary<string, string>> jsonList = JsonSplit.Split(json);
                if (jsonList.Count > 0)
                {
                    string[] items = key.Split('.');
                    string fKey = items[0];
                    int i = -1;
                    int fi = key.IndexOf('.');
                    if (int.TryParse(fKey, out i))//数字
                    {
                        if (i < jsonList.Count)
                        {
                            Dictionary<string, string> numJson = jsonList[i];
                            if (items.Length == 1)
                            {
                                result = ToJson(numJson);
                            }
                            else if (items.Length == 2) // 0.xxx
                            {
                                string sKey = items[1];
                                if (numJson.ContainsKey(sKey))
                                {
                                    result = numJson[sKey];
                                }
                            }
                            else
                            {
                                return GetSourceValue(ToJson(numJson), key.Substring(fi + 1));
                            }
                        }
                    }
                    else // 非数字
                    {
                        Dictionary<string, string> jsonDic = jsonList[0];
                        if (items.Length == 1)
                        {
                            if (jsonDic.ContainsKey(fKey))
                            {
                                result = jsonDic[fKey];
                            }
                        }
                        else if (jsonDic.ContainsKey(fKey)) // 取子集
                        {

                            return GetSourceValue(jsonDic[fKey], key.Substring(fi + 1));
                        }
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// a easy method for you to return a json
        /// <para>返回Json格式的结果信息</para>
        /// </summary>
        public static string OutResult(bool result, string msg)
        {
            return OutResult(result, msg, false);
        }

        /// <param name="noQuates">no ""</param>
        public static string OutResult(bool result, string msg, bool noQuates)
        {
            JsonHelper js = new JsonHelper(false, false);
            js.Add("success", result.ToString().ToLower(), true);
            js.Add("msg", msg, noQuates);
            return js.ToString();
        }
        public static string OutResult(bool result, object msgObj)
        {
            return OutResult(result, msgObj, null, null);
        }
        public static string OutResult(bool result, object msgObj, string name, object value, params object[] nameValues)
        {

            //JsonHelper js = new JsonHelper(false, false);
            //js.Add("success", result.ToString().ToLower(), true);
            //if (msgObj is string)
            //{
            //    js.Add("msg", Convert.ToString(msgObj));
            //}
            //else
            //{
            //    js.Add("msg", ToJson(msgObj), true);
            //}
            int num = name == null ? 2 : 4;
            object[] nvs = new object[nameValues.Length + num];
            nvs[0] = "msg";
            nvs[1] = msgObj;
            if (num == 4)
            {
                nvs[2] = name;
                nvs[3] = value;
            }
            if (nameValues.Length > 0)
            {
                nameValues.CopyTo(nvs, num);
            }
            return OutResult("success", result, nvs);

        }
        public static string OutResult(string name, object value, params object[] nameValues)
        {
            JsonHelper js = new JsonHelper();
            js.Add(name, value);
            for (int i = 0; i < nameValues.Length; i++) // 1
            {
                if (i % 2 == 0)
                {
                    string k = Convert.ToString(nameValues[i]);
                    i++;
                    object v = i == nameValues.Length ? null : nameValues[i];
                    js.Add(k, v);
                }
            }
            return js.ToString();
        }

        /// <summary>
        ///  split json to dicationary
        /// <para>将Json分隔成键值对。</para>
        /// </summary>
        public static Dictionary<string, string> Split(string json)
        {
            if (!string.IsNullOrEmpty(json))
            {
                json = json.Trim();
                if (json[0] != '{' && json[0] != '[')
                {
                    json = ToJson(json);
                }
                List<Dictionary<string, string>> result = JsonSplit.Split(json);
                if (result != null && result.Count > 0)
                {
                    return result[0];
                }
            }
            return null;
        }
        //public static List<Dictionary<string, string>> SplitArray(string jsonArray)
        //{
        //    return SplitArray(jsonArray, DefaultEscape);
        //}
        /// <summary>
        ///  split json to dicationary array
        /// <para>将Json 数组分隔成多个键值对。</para>
        /// </summary>
        public static List<Dictionary<string, string>> SplitArray(string jsonArray)
        {
            if (string.IsNullOrEmpty(jsonArray))
            {
                return null;
            }
            jsonArray = jsonArray.Trim();
            return JsonSplit.Split(jsonArray);
        }
        private void SetEscape(ref string value)
        {
            if (Escape == EscapeOp.No) { return; }
            bool isInsert = false;
            int len = value.Length;
            StringBuilder sb = new StringBuilder(len + 10);
            for (int i = 0; i < len; i++)
            {
                char c = value[i];
                if (Escape == EscapeOp.Encode)
                {
                    if (c < 32 || c == '"' || c == '\\')
                    {
                        sb.AppendFormat("@#{0}#@", (int)c);
                        isInsert = true;
                    }
                    else { sb.Append(c); }
                    continue;
                }

                if (c < 32)
                {

                    #region 十六进制符号处理
                    switch (c)
                    {
                        case '\n':
                            sb.Append("\\n");//直接替换追加。
                            break;
                        case '\t':
                            if (Escape == EscapeOp.Yes)
                            {
                                sb.Append("\\t");//直接替换追加
                            }
                            break;
                        case '\r':
                            if (Escape == EscapeOp.Yes)
                            {
                                sb.Append("\\r");//直接替换追加
                            }
                            break;
                        default:
                            break;
                    }
                    #endregion
                    // '\n'=10  '\r'=13 '\t'=9 都会被过滤。
                    isInsert = true;
                    continue;
                }
                #region 双引号和转义符号处理
                switch (c)
                {
                    case '"':
                        isInsert = true;
                        sb.Append("\\");
                        //if (i == 0 || value[i - 1] != '\\')//这个是强制转，不然整体格式有问题。
                        //{
                        //    isInsert = true;
                        //    sb.Append("\\");
                        //}
                        break;
                    case '\\':
                        //if (i < len - 1)
                        //{
                        //    switch (value[i + 1])
                        //    {
                        //      //  case '"':
                        //        case 'n':
                        //            case 'r'://r和t要转义，不过出事。
                        //            case 't':
                        //                isInsert = true;
                        //                sb.Append("\\");
                        //            break;
                        //        default:
                        //            //isOK = true;
                        //            break;
                        //    }
                        //}
                        bool isOK = Escape == EscapeOp.Yes;// || (i != 0 && i == len - 1 && value[i - 1] != '\\');// 如果是以\结尾,（非\\结尾时, 这部分是强制转，不会然影响整体格式）
                        if (!isOK && Escape == EscapeOp.Default && len > 1 && i < len - 1)//中间
                        {
                            switch (value[i + 1])
                            {
                                // case '"':
                                case 'n':
                                    //case 'r'://r和t要转义，不过出事。
                                    //case 't':
                                    break;
                                default:
                                    isOK = true;
                                    break;
                            }
                        }
                        if (isOK)
                        {
                            isInsert = true;
                            sb.Append("\\");
                        }
                        break;
                }
                #endregion
                sb.Append(c);
            }

            if (isInsert)
            {
                value = null;
                value = sb.ToString();
            }
            else { sb = null; }
        }
        /// <summary>
        /// 解码替换数据转义符
        /// </summary>
        public static string UnEscape(string result, EscapeOp op)
        {
            if (op == EscapeOp.No) { return result; }
            if (op == EscapeOp.Encode)
            {
                if (result.IndexOf("@#") > -1 && result.IndexOf("#@") > -1) // 先解系统编码
                {
                    MatchCollection matchs = Regex.Matches(result, @"@#(\d{1,2})#@", RegexOptions.Compiled);
                    if (matchs != null && matchs.Count > 0)
                    {
                        List<string> keys = new List<string>(matchs.Count);
                        foreach (Match match in matchs)
                        {
                            if (match.Groups.Count > 1)
                            {
                                int code = int.Parse(match.Groups[1].Value);
                                string charText = ((char)code).ToString();
                                result = result.Replace(match.Groups[0].Value, charText);
                            }
                        }
                    }
                }
                return result;
            }
            if (result.IndexOf("\\") > -1)
            {
                result = result.Replace("\\\\", "#&#=#");
                if (op == EscapeOp.Yes)
                {
                    result = result.Replace("\\t", "\t").Replace("\\r", "\r");
                }
                result = result.Replace("\\\"", "\"").Replace("\\n", "\n");//.Replace("\\\\","\\");
                result = result.Replace("#&#=#", "\\");
            }
            return result;
        }
    }

    // 扩展交互部分
    public partial class JsonHelper
    {
        /// <summary>
        /// 用于控制自循环的层级判断。
        /// </summary>
        internal int Level = 1;
        /// <summary>
        /// 用于自循环检测列表。
        /// </summary>
        internal MDictionary<int, int> LoopCheckList = new MDictionary<int, int>();
        /// <summary>
        /// Fill obj and get json from  ToString() method
        /// <para>从数据表中取数据填充,最终可输出json字符串</para>
        /// </summary>
        public void Fill(MDataTable table)
        {
            if (table == null)
            {
                ErrorMsg = "MDataTable object is null";
                return;
            }
            if (_AddSchema)
            {
                Fill(table.Columns, false);
            }
            //RowCount = table.Rows.Count;
            Total = table.RecordsAffected;

            if (table.Rows.Count > 0)
            {
                for (int i = 0; i < table.Rows.Count; i++)
                {
                    Fill(table.Rows[i]);
                }
            }
        }
        /// <summary>
        /// Fill obj and get json from  ToString() method
        /// <para>从数据行中取数据填充,最终可输出json字符串</para>
        /// </summary>
        public void Fill(MDataRow row)
        {
            if (row == null)
            {
                ErrorMsg = "MDataRow object is null";
                return;
            }

            for (int i = 0; i < row.Count; i++)
            {
                MDataCell cell = row[i];
                if (cell.IsJsonIgnore)
                {
                    continue;
                }
                if (_RowOp == RowOp.None || (!cell.IsNull && (cell.Struct.IsPrimaryKey || cell.State >= (int)_RowOp)))
                {
                    #region MyRegion
                    string name = row[i].ColumnName;
                    if (IsConvertNameToLower)
                    {
                        name = name.ToLower();
                    }

                    string value = cell.ToString();
                    int groupID = DataType.GetGroup(cell.Struct.SqlType);
                    bool noQuot = groupID == 1 || groupID == 3;
                    if (cell.IsNull)
                    {
                        value = "null";
                        noQuot = true;
                    }
                    else
                    {

                        if (groupID == 3 || (cell.Struct.MaxSize == 1 && groupID == 1)) // oracle 下的number 1会处理成bool类型
                        {
                            value = value.ToLower();
                        }
                        else if (groupID == 2)
                        {
                            DateTime dt;
                            if (DateTime.TryParse(value, out dt))
                            {
                                value = dt.ToString(DateTimeFormatter);
                            }
                        }
                        else if (groupID == 999)
                        {
                            int hash = cell.Value.GetHashCode();
                            //检测是否循环引用
                            if (LoopCheckList.ContainsKey(hash))
                            {
                                //continue;
                                int level = LoopCheckList[hash];
                                if (level < Level)
                                {
                                    continue;
                                }
                                else
                                {
                                    LoopCheckList[hash] = Level;//更新级别
                                }
                            }
                            else
                            {
                                LoopCheckList.Add(hash, Level);
                            }
                            Type t = cell.Struct.ValueType;
                            if (t.FullName == "System.Object")
                            {
                                t = cell.Value.GetType();
                            }
                            if (t.Name == "Byte[]")
                            {
                                value = Convert.ToBase64String(cell.Value as byte[]);
                            }
                            else if (t.Name == "String")
                            {
                                value = cell.StringValue;
                            }
                            else
                            {
                                if (cell.Value is IEnumerable)
                                {
                                    int len = ReflectTool.GetArgumentLength(ref t);
                                    if (len <= 1)//List<T>
                                    {
                                        JsonHelper js = new JsonHelper(false, false);
                                        js.Level = Level + 1;
                                        js.LoopCheckList = LoopCheckList;
                                        js.Escape = Escape;
                                        js._RowOp = _RowOp;
                                        js.DateTimeFormatter = DateTimeFormatter;
                                        js.IsConvertNameToLower = IsConvertNameToLower;
                                        if (cell.Value is MDataRowCollection)
                                        {
                                            MDataTable dtx = (MDataRowCollection)cell.Value;
                                            js.Fill(dtx);
                                        }
                                        else
                                        {
                                            js.Fill(cell.Value);
                                        }
                                        value = js.ToString(true);
                                        noQuot = true;
                                    }
                                    else if (len == 2)//Dictionary<T,K>
                                    {
                                        MDataRow dicRow = MDataRow.CreateFrom(cell.Value);
                                        dicRow.DynamicData = LoopCheckList;
                                        value = dicRow.ToJson(RowOp, IsConvertNameToLower, Escape);
                                        noQuot = true;
                                    }
                                }
                                else
                                {
                                    if (!t.FullName.StartsWith("System."))//普通对象。
                                    {
                                        MDataRow oRow = new MDataRow(TableSchema.GetColumnByType(t));
                                        oRow.DynamicData = LoopCheckList;
                                        oRow.LoadFrom(cell.Value);
                                        value = oRow.ToJson(RowOp, IsConvertNameToLower, Escape);
                                        noQuot = true;
                                    }
                                    else if (t.FullName == "System.Data.DataTable")
                                    {
                                        MDataTable dt = cell.Value as DataTable;
                                        dt.DynamicData = LoopCheckList;
                                        value = dt.ToJson(false, false, RowOp, IsConvertNameToLower, Escape);
                                        noQuot = true;
                                    }
                                }

                            }

                        }
                    }
                    Add(name, value, noQuot);

                    #endregion
                }

            }
            AddBr();
        }
        /// <summary>
        /// 从数据结构填充，最终可输出json字符串。
        /// </summary>
        /// <param name="column">数据结构</param>
        /// <param name="isFullSchema">false：输出单行的[列名：数据类型]；true：输出多行的完整的数据结构</param>
        public void Fill(MDataColumn column, bool isFullSchema)
        {
            if (column == null)
            {
                ErrorMsg = "MDataColumn object is null";
                return;
            }

            if (isFullSchema)
            {
                if (!string.IsNullOrEmpty(column.TableName))
                {
                    _AddHead = true;
                    headText.Append("{");
                    headText.Append("\"TableName\":\"" + column.TableName + "\",");
                    headText.Append("\"Description\":\"" + column.Description + "\",");
                    headText.Append("\"Columns\":");
                }
                foreach (MCellStruct item in column)
                {
                    Add("ColumnName", item.ColumnName);
                    Add("SqlType", item.ValueType.FullName);
                    Add("IsAutoIncrement", item.IsAutoIncrement.ToString().ToLower(), true);
                    Add("IsCanNull", item.IsCanNull.ToString().ToLower(), true);
                    Add("MaxSize", item.MaxSize.ToString(), true);
                    Add("Scale", item.Scale.ToString().ToLower(), true);
                    Add("IsPrimaryKey", item.IsPrimaryKey.ToString().ToLower(), true);
                    Add("DefaultValue", Convert.ToString(item.DefaultValue));
                    Add("Description", item.Description);
                    //新增属性
                    Add("TableName", item.TableName);
                    Add("IsUniqueKey", item.IsUniqueKey.ToString().ToLower(), true);
                    Add("IsForeignKey", item.IsForeignKey.ToString().ToLower(), true);
                    Add("FKTableName", item.FKTableName);

                    AddBr();
                }
            }
            else
            {
                for (int i = 0; i < column.Count; i++)
                {
                    Add(column[i].ColumnName, column[i].ValueType.FullName);
                }
                AddBr();
            }
            rowCount = 0;//重置为0
        }
        /// <summary>
        ///  Fill obj and get json from  ToString() method
        /// <para>可从类(对象,泛型List、泛型Dictionary）中填充，最终可输出json字符串。</para>
        /// </summary>
        /// <param name="obj">实体类对象</param>
        public void Fill(object obj)
        {
            if (obj != null)
            {
                if (obj is String || obj is ValueType)
                {
                    Fill(Convert.ToString(obj));
                }
                else if (obj is MDataTable)
                {
                    Fill(obj as MDataTable);
                }
                else if (obj is MDataRow)
                {
                    Fill(obj as MDataRow);
                }
                else if (obj is IEnumerable)
                {
                    #region IEnumerable
                    Type t = obj.GetType();
                    int len = ReflectTool.GetArgumentLength(ref t);
                    if (len == 1)
                    {
                        foreach (object o in obj as IEnumerable)
                        {
                            if (o is MDataTable)
                            {
                                Fill(o as MDataTable);
                            }
                            else if (o is DataTable)
                            {
                                MDataTable dt = o as DataTable;
                                Fill(dt);
                            }
                            else if (o is String || o is DateTime || o is Enum || o is Guid)
                            {
                                string str = o.ToString();
                                if ((str[0] == '{' || str[0] == '[') && JsonSplit.IsJson(str))
                                {
                                    Fill(MDataRow.CreateFrom(o));
                                }
                                else
                                {
                                    if (o is String) { SetEscape(ref str); }
                                    jsonItems.Add("\"" + str + "\"");
                                }
                            }
                            else if (o is ValueType)
                            {
                                jsonItems.Add(o.ToString());
                            }
                            else
                            {
                                Fill(MDataRow.CreateFrom(o));
                            }
                        }
                    }
                    else if (len == 2)
                    {
                        Fill(MDataRow.CreateFrom(obj));
                    }
                    #endregion
                }
                else if (obj is DataTable)
                {
                    MDataTable dt = obj as DataTable;
                    Fill(dt);
                }
                else if (obj is DataRow)
                {
                    MDataRow row = obj as DataRow;
                    Fill(row);
                }
                else if (obj is DataColumnCollection)
                {
                    MDataColumn mdc = obj as DataColumnCollection;
                    Fill(mdc, true);
                }
                else
                {
                    MDataRow row = new MDataRow();
                    row.LoadFrom(obj);
                    Fill(row);
                }
            }
        }

        public void Fill(string query)
        {
            if (!string.IsNullOrEmpty(query))
            {
                query = query.Trim('?');
                string[] items = query.Split('&');
                foreach (string item in items)
                {
                    if (!string.IsNullOrEmpty(item))
                    {
                        int index = item.IndexOf('=');
                        if (index > -1)
                        {
                            Add(item.Substring(0, index), item.Substring(index + 1, item.Length - index - 1));
                        }
                        else
                        {
                            Add(item, "");
                        }
                    }
                }
            }
        }

        private static Dictionary<string, object> lockList = new Dictionary<string, object>();
        /// <summary>
        /// 从Json字符串中反加载成数据表
        /// </summary>
        internal static MDataTable ToMDataTable(string jsonOrFileName, MDataColumn mdc, EscapeOp op)
        {

            MDataTable table = new MDataTable("SysDefaultLoadFromJson");
            if (mdc != null)
            {
                table.Columns = mdc;
            }
            if (string.IsNullOrEmpty(jsonOrFileName))
            {
                return table;
            }
            else
            {
                jsonOrFileName = jsonOrFileName.Trim();
            }
            try
            {
                #region 读取Json


                string json = string.Empty;
                #region 获取Json字符串
                if (!jsonOrFileName.StartsWith("{") && !jsonOrFileName.StartsWith("["))//读取文件。
                {
                    if (System.IO.File.Exists(jsonOrFileName))
                    {
                        table.TableName = Path.GetFileNameWithoutExtension(jsonOrFileName);
                        if (table.Columns.Count == 0)
                        {
                            table.Columns = MDataColumn.CreateFrom(jsonOrFileName, false);
                        }
                        json = IOHelper.ReadAllText(jsonOrFileName).Trim(',', ' ', '\r', '\n');
                    }
                }
                else
                {
                    json = jsonOrFileName;
                }
                if (json.StartsWith("{"))
                {
                    json = '[' + json + ']';
                }
                #endregion
                List<Dictionary<string, string>> result = SplitArray(json);
                if (result != null && result.Count > 0)
                {
                    #region 加载数据
                    if (result.Count == 1)
                    {
                        #region 自定义输出头判断
                        Dictionary<string, string> dic = result[0];
                        if (dic.ContainsKey("total") && dic.ContainsKey("rows"))
                        {
                            int count = 0;
                            if (int.TryParse(dic["total"], out count))
                            {
                                table.RecordsAffected = count;//还原记录总数。
                            }
                            result = SplitArray(dic["rows"]);
                        }
                        else if (dic.ContainsKey("TableName") && dic.ContainsKey("Columns"))
                        {
                            table.TableName = dic["TableName"];
                            if (dic.ContainsKey("Description"))
                            {
                                table.Description = dic["Description"];
                            }
                            result = SplitArray(dic["Columns"]);
                        }
                        #endregion
                    }
                    if (result != null && result.Count > 0)
                    {
                        Dictionary<string, string> keyValueDic = null;
                        for (int i = 0; i < result.Count; i++)
                        {
                            keyValueDic = result[i];
                            if (i == 0)
                            {
                                #region 首行列头检测
                                bool addColumn = table.Columns.Count == 0;
                                bool isContinue = false;
                                int k = 0;
                                foreach (KeyValuePair<string, string> item in keyValueDic)
                                {
                                    if (k == 0 && item.Value.StartsWith("System."))
                                    {
                                        isContinue = true;
                                    }
                                    if (!addColumn)
                                    {
                                        break;
                                    }
                                    if (!table.Columns.Contains(item.Key))
                                    {
                                        SqlDbType type = SqlDbType.NVarChar;
                                        if (isContinue && item.Value.StartsWith("System."))//首行是表结构
                                        {
                                            type = DataType.GetSqlType(item.Value.Replace("System.", string.Empty));
                                        }
                                        table.Columns.Add(item.Key, type, (k == 0 && type == SqlDbType.Int));
                                        if (k > keyValueDic.Count - 3 && type == SqlDbType.DateTime)
                                        {
                                            table.Columns[k].DefaultValue = SqlValue.GetDate;
                                        }
                                    }
                                    k++;
                                }
                                if (isContinue)
                                {
                                    continue;
                                }
                                #endregion
                            }


                            bool isKeyValue = table.Columns.Count == 2 && table.Columns[1].ColumnName == "Value" && (table.Columns[0].ColumnName == "Key" || table.Columns[0].ColumnName == "Name");

                            if (isKeyValue)
                            {
                                foreach (KeyValuePair<string, string> item in keyValueDic)
                                {
                                    MDataRow row = table.NewRow(true);
                                    row.Set(0, item.Key);
                                    row.Set(1, item.Value);
                                }
                            }
                            else
                            {
                                MDataRow row = table.NewRow(true);
                                MDataCell cell = null;
                                foreach (KeyValuePair<string, string> item in keyValueDic)
                                {

                                    cell = row[item.Key];
                                    if (cell == null && mdc == null)
                                    {
                                        table.Columns.Add(item.Key, SqlDbType.NVarChar);
                                        cell = row[item.Key];
                                    }
                                    if (cell != null)
                                    {
                                        string val = UnEscape(item.Value, op);
                                        cell.Value = val;
                                        cell.State = 1;
                                    }

                                }
                            }

                        }
                    }
                    #endregion
                }
                else
                {
                    List<string> items = JsonSplit.SplitEscapeArray(json);
                    if (items != null && items.Count > 0)
                    {
                        if (mdc == null)
                        {
                            table.Columns.Add("Key");
                        }
                        foreach (string item in items)
                        {
                            table.NewRow(true).Set(0, item.Trim('"', '\''));
                        }
                    }
                }
                #endregion
            }
            catch (Exception err)
            {
                Log.Write(err, LogType.Error);
            }

            return table;
        }
        /// <summary>
        /// 将Json转换成集合
        /// </summary>
        /// <typeparam name="T">集合类型</typeparam>
        /// <param name="json">json数据</param>
        /// <returns></returns>
        private static T ToIEnumerator<T>(string json, EscapeOp op)
            where T : class
        {
            Type t = typeof(T);
            if (t.FullName.StartsWith("System.Collections."))
            {
                Type[] ts;
                int argLength = ReflectTool.GetArgumentLength(ref t, out ts);
                #region Dictionary
                if (t.FullName.Contains("Dictionary") && argLength == 2 && ts[0].Name == "String" && ts[1].Name == "String")
                {
                    Dictionary<string, string> dic = Split(json);
                    return dic as T;
                }

                T objT = Activator.CreateInstance<T>();
                Type oT = objT.GetType();
                MethodInfo mi = null;
                try
                {
                    mi = oT.GetMethod("Add");
                }
                catch
                {

                }
                if (mi == null)
                {
                    mi = oT.GetMethod("Add", new Type[] { typeof(string), typeof(string) });
                }
                if (mi != null)
                {
                    if (argLength == 1)
                    {
                        List<Dictionary<string, string>> items = JsonSplit.Split(json);
                        if (items != null && items.Count > 0)
                        {
                            foreach (Dictionary<string, string> item in items)
                            {
                                mi.Invoke(objT, new object[] { MDataRow.CreateFrom(item).ToEntity(ts[0]) });
                            }
                        }
                    }
                    else if (argLength == 2)
                    {
                        Dictionary<string, string> dic = Split(json);
                        if (dic != null && dic.Count > 0)
                        {
                            foreach (KeyValuePair<string, string> kv in dic)
                            {
                                mi.Invoke(objT, new object[] { Convert.ChangeType(kv.Key, ts[0]), Convert.ChangeType(UnEscape(kv.Value, op), ts[1]) });
                            }
                        }
                    }
                    return objT;
                }
                #endregion

            }
            else if (t.FullName.EndsWith("[]"))
            {
                Object o = new MDataRow().GetObj(t, json);
                if (o != null)
                {
                    return (T)o;
                }
            }
            return default(T);
        }
        public static T ToEntity<T>(string json) where T : class
        {
            return ToEntity<T>(json, DefaultEscape);
        }
        /// <summary>
        /// Convert json to Entity
        /// <para>将Json转换为实体</para>
        /// </summary>
        /// <typeparam name="T">Type<para>类型</para></typeparam>
        public static T ToEntity<T>(string json, EscapeOp op) where T : class
        {
            Type t = typeof(T);
            if (t.FullName.StartsWith("System.Collections.") || t.FullName.EndsWith("[]"))
            {
                return ToIEnumerator<T>(json, op);
            }
            else
            {
                MDataRow row = new MDataRow(TableSchema.GetColumnByType(t));
                row.LoadFrom(json, op);
                return row.ToEntity<T>();
            }
        }
        public static List<T> ToList<T>(string json) where T : class
        {
            return ToList<T>(json, DefaultEscape);
        }
        /// <summary>
        ///  Convert json to Entity List
        ///  <para>将Json转换为实体列表</para>
        /// </summary>
        /// <typeparam name="T">Type<para>类型</para></typeparam>
        public static List<T> ToList<T>(string json, EscapeOp op) where T : class
        {
            return ToMDataTable(json, TableSchema.GetColumnByType(typeof(T)), op).ToList<T>();
        }
        /// <summary>
        /// Convert object to json
        /// <para>将一个对象（实体，泛型List，字典Dictionary）转成Json</para>
        /// </summary>
        public static string ToJson(object obj)
        {
            return ToJson(obj, false, RowOp.IgnoreNull);
        }


        public static string ToJson(object obj, bool isConvertNameToLower)
        {
            return ToJson(obj, isConvertNameToLower, RowOp.IgnoreNull);
        }
        public static string ToJson(object obj, bool isConvertNameToLower, RowOp rowOp)
        {
            return ToJson(obj, isConvertNameToLower, rowOp, DefaultEscape);
        }

        /// <param name="op">default value is RowOp.All
        /// <para>默认值为RowOp.All</para></param>
        public static string ToJson(object obj, bool isConvertNameToLower, RowOp rowOp, EscapeOp escapeOp)
        {
            string text = Convert.ToString(obj);
            if (text == "")
            {
                return "{}";
            }
            else if (text[0] == '{' || text[0] == '[')
            {
                if (IsJson(text))
                {
                    return text;
                }
            }
            else if (text[0] == '<' && text[text.Length - 1] == '>')
            {
                return XmlToJson(text, true);
            }

            JsonHelper js = new JsonHelper();
            js.LoopCheckList.Add(obj.GetHashCode(), 0);
            js.Escape = escapeOp;
            js.IsConvertNameToLower = isConvertNameToLower;
            js.RowOp = rowOp;
            js.Fill(obj);
            return js.ToString(obj is IList || obj is MDataTable || obj is DataTable);
        }



        #region Xml 转 Json

        /// <summary>
        /// 转Json
        /// <param name="xml">xml字符串</param>
        /// <param name="isConvertNameToLower">字段是否转小写</param>
        /// <param name="isWithAttr">是否将属性值也输出</param>
        /// </summary>
        private static string XmlToJson(string xml, bool isWithAttr)
        {
            using (XHtmlAction action = new XHtmlAction(false, true))
            {
                try
                {
                    action.LoadXml(xml);
                    return action.ToJson(action.XmlDoc.DocumentElement, isWithAttr);
                }
                catch (Exception err)
                {
                    Log.WriteLogToTxt(err, LogType.Error);
                    return string.Empty;
                }

            }
        }

        #endregion


        #region Json转Xml
        /// <summary>
        /// Convert json to Xml
        /// <para>将一个Json转成Xml</para>
        /// </summary>
        public static string ToXml(string json)
        {
            return ToXml(json, true);
        }

        public static string ToXml(string json, bool isWithAttr)
        {
            return ToXml(json, isWithAttr, DefaultEscape);
        }
        public static string ToXml(string json, bool isWithAttr, EscapeOp op)
        {
            return ToXml(json, isWithAttr, op, null);
        }
        /// <param name="isWithAttr">default value is true
        /// <para>是否转成属性，默认true</para></param>
        public static string ToXml(string json, bool isWithAttr, EscapeOp op, string rootName)
        {
            if (!string.IsNullOrEmpty(rootName))
            {
                json = string.Format("{{\"{0}\":{1}}}", rootName, json);
            }
            StringBuilder xml = new StringBuilder();
            xml.Append("<?xml version=\"1.0\"  standalone=\"yes\"?>");
            List<Dictionary<string, string>> dicList = JsonSplit.Split(json);
            if (dicList != null && dicList.Count > 0)
            {
                bool addRoot = dicList.Count > 1 || dicList[0].Count > 1;
                if (addRoot)
                {
                    xml.Append(string.Format("<{0}>", rootName ?? "root"));//</root>";
                }

                xml.Append(GetXmlList(dicList, isWithAttr, op));

                if (addRoot)
                {
                    xml.Append(string.Format("</{0}>", rootName ?? "root"));//</root>";
                }

            }
            return xml.ToString();
        }

        private static string GetXmlList(List<Dictionary<string, string>> dicList, bool isWithAttr, EscapeOp op)
        {
            if (dicList == null || dicList.Count == 0)
            {
                return string.Empty;
            }
            StringBuilder xml = new StringBuilder();
            for (int i = 0; i < dicList.Count; i++)
            {
                xml.Append(GetXml(dicList[i], isWithAttr, op));
            }
            return xml.ToString();
        }

        private static string GetXml(Dictionary<string, string> dic, bool isWithAttr, EscapeOp op)
        {
            StringBuilder xml = new StringBuilder();
            bool isJson = false;
            foreach (KeyValuePair<string, string> item in dic)
            {
                isJson = IsJson(item.Value);
                if (!isJson)
                {
                    xml.AppendFormat("<{0}>{1}</{0}>", item.Key, FormatCDATA(UnEscape(item.Value, op)));
                }
                else
                {
                    string key = item.Key;
                    if (key.EndsWith("List") && isWithAttr)
                    {
                        xml.AppendFormat("<{0}>", key);
                        key = key.Substring(0, key.Length - 4);
                    }
                    List<Dictionary<string, string>> jsonList = JsonSplit.Split(item.Value);
                    if (jsonList != null && jsonList.Count > 0)
                    {
                        if (!isWithAttr)
                        {
                            xml.AppendFormat("<{0}>", item.Key);
                        }
                        for (int j = 0; j < jsonList.Count; j++)
                        {
                            if (isWithAttr)
                            {
                                xml.Append(GetXmlElement(key, jsonList[j], op));
                            }
                            else
                            {
                                xml.Append(GetXml(jsonList[j], isWithAttr, op));
                            }
                        }
                        if (!isWithAttr)
                        {
                            xml.AppendFormat("</{0}>", key);
                        }
                    }
                    else // 空Json {}
                    {
                        xml.AppendFormat("<{0}></{0}>", key);
                    }

                    if (item.Key.EndsWith("List") && isWithAttr)
                    {
                        xml.AppendFormat("</{0}>", item.Key);
                    }
                }
            }
            return xml.ToString();
        }

        private static string GetXmlElement(string parentName, Dictionary<string, string> dic, EscapeOp op)
        {
            StringBuilder xml = new StringBuilder();
            Dictionary<string, string> jsonDic = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            xml.Append("<" + parentName);
            foreach (KeyValuePair<string, string> kv in dic)
            {
                if (kv.Value.IndexOf('"') > -1 || kv.Value.Length > 50
                    || kv.Key.Contains("Remark") || kv.Key.Contains("Description") || kv.Key.Contains("Rule")
                    || IsJson(kv.Value)) // 属性不能带双引号，所以转到元素处理。
                {
                    jsonDic.Add(kv.Key, kv.Value);
                }
            }
            //InnerText 节点存在=》（如果有元素节点，则当属性处理；若无，则当InnerText）
            bool useForInnerText = dic.ContainsKey(parentName) && jsonDic.Count == 0;
            foreach (KeyValuePair<string, string> kv in dic)
            {
                if (!jsonDic.ContainsKey(kv.Key) && (kv.Key != parentName || !useForInnerText))
                {
                    xml.AppendFormat(" {0}=\"{1}\"", kv.Key, kv.Value);//先忽略同名属性，内部InnerText节点，
                }
            }
            xml.Append(">");
            if (useForInnerText)
            {
                xml.Append(FormatCDATA(UnEscape(dic[parentName], op)));//InnerText。
            }
            else if (jsonDic.Count > 0)
            {
                xml.Append(GetXml(jsonDic, true, op));//数组，当元素处理。
            }
            xml.Append("</" + parentName + ">");

            return xml.ToString();
        }
        private static string FormatCDATA(string text)
        {
            if (text.LastIndexOfAny(new char[] { '<', '>', '&' }) > -1 && !text.StartsWith("<![CDATA["))
            {
                text = "<![CDATA[" + text.Trim() + "]]>";
            }
            return text;
        }
        #endregion
    }

    public partial class JsonHelper
    {
        /// <summary>
        /// 读取文本中的Json（并去掉注释）
        /// </summary>
        /// <returns></returns>
        internal static string ReadJson(string filePath)
        {
            string json = string.Empty;
            if (System.IO.File.Exists(filePath))
            {
                #region Read from path
                json = IOHelper.ReadAllText(filePath);
                if (!string.IsNullOrEmpty(json))
                {
                    int index = json.LastIndexOf("/*");
                    if (index > -1)//去掉注释
                    {
                        json = Regex.Replace(json, @"/\*[.\s\S]*?\*/", string.Empty, RegexOptions.IgnoreCase);
                    }
                    char splitChar = '\n';
                    if (json.IndexOf(splitChar) > -1)
                    {
                        string[] items = json.Split(splitChar);
                        StringBuilder sb = new StringBuilder();
                        foreach (string item in items)
                        {
                            if (!item.TrimStart(' ', '\r', '\t').StartsWith("//"))
                            {
                                sb.Append(item.Trim(' ', '\r', '\t'));
                            }
                        }
                        json = sb.ToString();
                    }
                    if (json.IndexOf("\\\\") > -1)
                    {
                        json = json.Replace("\\\\", "\\");
                    }
                }
                #endregion
            }
            return json;
        }
    }
}