using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Transactions;
using System.Data.SqlClient;
using System.Linq.Expressions;
using System.Data;
using Bowin.Common.Linq.DB;
using System.Configuration;
using System.Reflection;
using System.Data.Entity.Core.Objects;
using System.Data.Entity.Core.Objects.DataClasses;
using System.Data.Linq.Mapping;
using System.Data.Entity.Core;
using EntityFramework.Extensions;
using AutoMapper;
using System.Dynamic;

namespace Bowin.Common.Linq.Entity
{
    public static class EFModelExt
    {
//        public static void Delete<TEntity, TKeys>(this DbSet<TEntity> dbSet, IEnumerable<TKeys> keyList) where TEntity : class
//        {
//            var keyType = typeof(TKeys);
//            string tableName = typeof(TEntity).Name;
//            IList<TEntity> result = new List<TEntity>();

//            if (keyType.IsValueType || keyType.Name.StartsWith("String"))
//            {
//                throw (new EntityException("keyList参数必须是复杂类型的列表。"));
//            }

//            string tmpTableName = "##DeleteTemp" + Guid.NewGuid().ToString().Replace("-", "");
//            SqlConnection conn;

//            if (SqlConnectionManager.IsGlobalConnectionStarted)
//            {
//                conn = SqlConnectionManager.GetConnection(dbSet.AsQueryable().GetConnectionKey());
//            }
//            else
//            {
//                //conn = new SqlConnection(dbSet.AsQueryable().GetConnection().ConnectionString);
//                conn = (SqlConnection)dbSet.AsQueryable().GetConnection();
//            }
//            conn.BulkCopyToTempTable(tmpTableName, keyList);
//            string sql = @"
//delete t 
//from " + tableName + @" t 
//inner join " + tmpTableName + @" tmp on ";

//            var keyExpression = "";
//            foreach (var property in keyType.GetProperties())
//            {
//                if (property.PropertyType.IsValueType || property.PropertyType.Name.StartsWith("String"))
//                {
//                    var field = property.Name;

//                    if (keyExpression != "")
//                    {
//                        keyExpression += " and ";
//                    }

//                    keyExpression += "t.[" + field + "]" + "=tmp.[" + field + "]";
//                }
//            }

//            sql += keyExpression;

//            var command = new SqlCommand(sql, conn);
//            command.CommandTimeout = 12000;
//            command.CommandType = CommandType.Text;
//            command.ExecuteNonQuery();

//            command.CommandText = "drop table " + tmpTableName;
//            command.CommandType = System.Data.CommandType.Text;
//            command.ExecuteNonQuery();

//            if (!SqlConnectionManager.IsGlobalConnectionStarted)
//            {
//                conn.Close();
//            }
//        }

//        public static void Delete<TEntity, TKeys, TMatchKey>(this DbSet<TEntity> dbSet, IEnumerable<TKeys> keyList, Expression<Func<TEntity, TMatchKey>> singleKey) where TEntity : class
//        {
//            var keyType = typeof(TKeys);
//            string tableName = typeof(TEntity).Name;
//            var singleColumnName = "";
//            IList<TEntity> result = new List<TEntity>();

//            #region 检查参数输入
//            if (keyType.IsValueType || keyType.Name.StartsWith("String"))
//            {
//                singleColumnName = "TmpColumn";
//            }
//            else
//            {
//                throw (new EntityException("keyList参数必须是基础类型的列表。"));
//            }

//            if (singleKey.Body.NodeType != ExpressionType.MemberAccess)
//            {
//                throw (new EntityException("singleKey参数必须是MemberAccess类型的Expression"));
//            }
//            #endregion

//            string tmpTableName = "##DeleteTemp" + Guid.NewGuid().ToString().Replace("-", "");
//            SqlConnection conn;

//            if (SqlConnectionManager.IsGlobalConnectionStarted)
//            {
//                conn = SqlConnectionManager.GetConnection(dbSet.AsQueryable().GetConnectionKey());
//            }
//            else
//            {
//                //conn = new SqlConnection(dbSet.AsQueryable().GetConnection().ConnectionString);
//                conn = (SqlConnection)dbSet.AsQueryable().GetConnection();
//            }
//            conn.BulkCopyToTempTable(tmpTableName, keyList, singleColumnName);
//            string sql = @"
//delete t 
//from " + tableName + @" t 
//inner join " + tmpTableName + @" tmp on ";

//            if (singleColumnName != "")
//            {
//                sql += "t.[" + ((MemberExpression)singleKey.Body).Member.Name + "]=tmp.TmpColumn";
//            }

//            var command = new SqlCommand(sql, conn);
//            command.CommandTimeout = 12000;
//            command.CommandType = CommandType.Text;
//            command.ExecuteNonQuery();

//            command.CommandText = "drop table " + tmpTableName;
//            command.CommandType = System.Data.CommandType.Text;
//            command.ExecuteNonQuery();

//            if (!SqlConnectionManager.IsGlobalConnectionStarted)
//            {
//                conn.Close();
//            }
//        }

//        public static void Delete<TEntity, TKeys, TMatchKey>(this DbSet<TEntity> dbSet, SqlConnection db, IEnumerable<TKeys> keyList, Expression<Func<TEntity, TMatchKey>> singleKey) where TEntity : class
//        {
//            var keyType = typeof(TKeys);
//            string tableName = typeof(TEntity).Name;
//            var singleColumnName = "";
//            IList<TEntity> result = new List<TEntity>();

//            #region 检查参数输入
//            if (keyType.IsValueType || keyType.Name.StartsWith("String"))
//            {
//                singleColumnName = "TmpColumn";
//            }
//            else
//            {
//                throw (new EntityException("keyList参数必须是基础类型的列表。"));
//            }

//            if (singleKey.Body.NodeType != ExpressionType.MemberAccess)
//            {
//                throw (new EntityException("singleKey参数必须是MemberAccess类型的Expression"));
//            }
//            #endregion

//            string tmpTableName = "##DeleteTemp" + Guid.NewGuid().ToString().Replace("-", "");
//            db.BulkCopyToTempTable(tmpTableName, keyList, singleColumnName);
//            string sql = @"
//delete t 
//from " + tableName + @" t 
//inner join " + tmpTableName + @" tmp on ";

//            if (singleColumnName != "")
//            {
//                sql += "t.[" + ((MemberExpression)singleKey.Body).Member.Name + "]=tmp.TmpColumn";
//            }

//            var command = new SqlCommand(sql, db);
//            command.CommandTimeout = 12000;
//            command.CommandType = CommandType.Text;
//            command.ExecuteNonQuery();

//            command.CommandText = "drop table " + tmpTableName;
//            command.CommandType = System.Data.CommandType.Text;
//            command.ExecuteNonQuery();
//        }

        /// <summary>
        /// 只有预计关键字数量比较多的时候才使用
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <typeparam name="TKeys"></typeparam>
        /// <param name="queryable"></param>
        /// <param name="keyList"></param>
        /// <returns></returns>
        public static IList<TEntity> SelectByKeys<TEntity, TKeys>(this IQueryable<TEntity> queryable, IEnumerable<TKeys> keyList) where TEntity : class
        {
            var keyType = typeof(TKeys);
            IList<TEntity> result = new List<TEntity>();
            var resultProperties = typeof(TEntity).GetProperties();

            if (keyType.IsValueType || keyType.Name.StartsWith("String"))
            {
                throw (new EntityException("keyList参数必须是复杂类型的列表。"));
            }

            var tableGuid = Guid.NewGuid().ToString().Replace("-", "");
            var columnString = tableGuid.Substring(10, 4);
            string tmpTableName = "##SelectTemp" + tableGuid;
            SqlConnection conn;

            if (SqlConnectionManager.IsGlobalConnectionStarted)
            {
                conn = SqlConnectionManager.GetConnection(queryable.GetConnectionKey());
            }
            else
            {
                //conn = new SqlConnection(queryable.GetConnection().ConnectionString);
                conn = (SqlConnection)queryable.GetConnection();
            }
            var parameters = queryable.GetParamters();
            conn.BulkCopyToTempTable(tmpTableName, keyList);
            string sql = @"
select t.* 
from (
    " + queryable.ToString() + @"
) t 
inner join " + tmpTableName + @" tmp on ";

            var keyExpression = "";
            foreach (var property in keyType.GetProperties())
            {
                if (property.PropertyType.IsValueType || property.PropertyType.Name.StartsWith("String"))
                {
                    var field = property.Name;

                    if (keyExpression != "")
                    {
                        keyExpression += " and ";
                    }

                    keyExpression += "t.[" + field + "]" + "=tmp.[" + field + "]";
                }
            }

            sql += keyExpression;

            var command = new SqlCommand(sql, conn);
            command.CommandTimeout = 12000;
            command.CommandType = CommandType.Text;

            foreach (var parameter in parameters)
            {
                SqlParameter sqlParameter = new SqlParameter();
                sqlParameter.ParameterName = parameter.Name;
                sqlParameter.Value = parameter.Value;
                command.Parameters.Add(sqlParameter);
            }
            var reader = command.ExecuteReader();

            result = ParseDataReaderToEntity<TEntity>(queryable.Expression, reader);

            command.CommandText = "drop table " + tmpTableName;
            command.CommandType = System.Data.CommandType.Text;
            command.ExecuteNonQuery();

            if (!SqlConnectionManager.IsGlobalConnectionStarted)
            {
                conn.Close();
            }

            return result;
        }

        private static List<TEntity> ParseDataReaderToEntity<TEntity>(SqlDataReader reader)
        {
            var result = new List<TEntity>();
            var entityType = typeof(TEntity);
            try
            {
                var resultProperties = entityType.GetProperties();
                while (reader.Read())
                {
                    TEntity entity;

                    if (!entityType.Name.Contains("<>f__AnonymousType"))
                    {
                        entity = (TEntity)entityType.Assembly.CreateInstance(entityType.FullName);
                        for (var i = 0; i < resultProperties.Length; i++)
                        {
                            try
                            {
                                resultProperties[i].SetValue(entity, reader[resultProperties[i].Name], null);
                            }
                            catch
                            {
                            }
                        }
                    }
                    else
                    {
                        var objAttrs = new object[resultProperties.Length];
                        for (var i = 0; i < resultProperties.Length; i++)
                        {
                            objAttrs[i] = reader[resultProperties[i].Name];
                        }
                        entity = (TEntity)Activator.CreateInstance(entityType, objAttrs);
                    }

                    result.Add(entity);
                }
            }
            catch
            { }
            finally
            {
                reader.Close();
            }

            return result;
        }

        private static List<TEntity> ParseDataReaderToEntity<TEntity>(Expression queryExpression, SqlDataReader reader)
        {
            if (queryExpression.NodeType != ExpressionType.Call)
            {
                return ParseDataReaderToEntity<TEntity>(reader);
            }
            if (!(((MethodCallExpression)queryExpression).Method.Name == "Select" && ((MethodCallExpression)queryExpression).Arguments.Count == 2))
            {
                return ParseDataReaderToEntity<TEntity>(reader);
            }
            if (((MethodCallExpression)queryExpression).Arguments[1].NodeType != ExpressionType.Quote)
            {
                return ParseDataReaderToEntity<TEntity>(reader);
            }
            var initialExpression = ((UnaryExpression)((MethodCallExpression)queryExpression).Arguments[1]).Operand;

            if (initialExpression.NodeType == ExpressionType.Lambda)
            {
                var bodyExpression = ((LambdaExpression)initialExpression).Body;
                if (bodyExpression.NodeType == ExpressionType.MemberInit)
                {
                    var bindList = ((MemberInitExpression)bodyExpression).Bindings;
                    var result = new List<TEntity>();
                    var entityType = typeof(TEntity);
                    try
                    {
                        while (reader.Read())
                        {
                            TEntity entity;
                            var offset = reader.FieldCount - bindList.Count;

                            if (!entityType.Name.Contains("<>f__AnonymousType"))
                            {
                                entity = (TEntity)entityType.Assembly.CreateInstance(entityType.FullName);

                                for (var i = 0; i < bindList.Count; i++)
                                {
                                    try
                                    {
                                        ((PropertyInfo)bindList[i].Member).SetValue(entity, reader[i + offset], null);
                                    }
                                    catch
                                    {
                                    }
                                }
                            }
                            else
                            {
                                var objAttrs = new object[bindList.Count];
                                for (var i = 0; i < bindList.Count; i++)
                                {
                                    objAttrs[i] = reader[i];
                                }
                                entity = (TEntity)Activator.CreateInstance(entityType, objAttrs);
                            }

                            result.Add(entity);
                        }
                    }
                    catch
                    { }
                    finally
                    {
                        reader.Close();
                    }

                    return result;
                }
                else
                {
                    return ParseDataReaderToEntity<TEntity>(reader);
                }
            }
            else
            {
                return ParseDataReaderToEntity<TEntity>(reader);
            }
        }

        /// <summary>
        /// 只有预计关键字数量比较多的时候才使用
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <typeparam name="TKeys"></typeparam>
        /// <param name="repository"></param>
        /// <param name="keyList"></param>
        /// <returns></returns>
        public static IList<TEntity> SelectByKeys<TEntity, TKeys>(this DbSet<TEntity> dbSet, IEnumerable<TKeys> keyList) where TEntity : class
        {
            var keyType = typeof(TKeys);
            string tableName = typeof(TEntity).Name;
            IList<TEntity> result = new List<TEntity>();
            var resultProperties = typeof(TEntity).GetProperties();

            if (keyType.IsValueType || keyType.Name.StartsWith("String"))
            {
                throw (new EntityException("keyList参数必须是复杂类型的列表。"));
            }

            string tmpTableName = "##SelectTemp" + Guid.NewGuid().ToString().Replace("-", "");
            SqlConnection conn;

            if (SqlConnectionManager.IsGlobalConnectionStarted)
            {
                conn = SqlConnectionManager.GetConnection(dbSet.AsQueryable().GetConnectionKey());
            }
            else
            {
                //conn = new SqlConnection(dbSet.AsQueryable().GetConnection().ConnectionString);
                conn = (SqlConnection)dbSet.AsQueryable().GetConnection();
            }
            conn.BulkCopyToTempTable(tmpTableName, keyList);
            string sql = @"
select t.* 
from " + tableName + @" t 
inner join " + tmpTableName + @" tmp on ";

            var keyExpression = "";
            foreach (var property in keyType.GetProperties())
            {
                if (property.PropertyType.IsValueType || property.PropertyType.Name.StartsWith("String"))
                {
                    var field = property.Name;

                    if (keyExpression != "")
                    {
                        keyExpression += " and ";
                    }

                    keyExpression += "t.[" + field + "]" + "=tmp.[" + field + "]";
                }
            }

            sql += keyExpression;

            var command = new SqlCommand(sql, conn);
            command.CommandTimeout = 12000;
            command.CommandType = CommandType.Text;
            var reader = command.ExecuteReader();

            result = ParseDataReaderToEntity<TEntity>(reader);

            command.CommandText = "drop table " + tmpTableName;
            command.CommandType = System.Data.CommandType.Text;
            command.ExecuteNonQuery();

            if (!SqlConnectionManager.IsGlobalConnectionStarted)
            {
                conn.Close();
            }

            return result;
        }

        public static IList<TEntity> SelectByKeys<TEntity, TKeys, TMatchKey>(this DbSet<TEntity> dbSet, IEnumerable<TKeys> keyList, Expression<Func<TEntity, TMatchKey>> singleKey) where TEntity : class
        {
            var keyType = typeof(TKeys);
            string tableName = typeof(TEntity).Name;
            var singleColumnName = "";
            IList<TEntity> result = new List<TEntity>();
            var resultProperties = typeof(TEntity).GetProperties();

            #region 检查参数输入
            if (keyType.IsValueType || keyType.Name.StartsWith("String"))
            {
                singleColumnName = "TmpColumn";
            }
            else
            {
                throw (new EntityException("keyList参数必须是基础类型的列表。"));
            }

            if (singleKey.Body.NodeType != ExpressionType.MemberAccess)
            {
                throw (new EntityException("singleKey参数必须是MemberAccess类型的Expression"));
            }
            #endregion

            string tmpTableName = "##SelectTemp" + Guid.NewGuid().ToString().Replace("-", "");
            SqlConnection conn;

            if (SqlConnectionManager.IsGlobalConnectionStarted)
            {
                conn = SqlConnectionManager.GetConnection(dbSet.AsQueryable().GetConnectionKey());
            }
            else
            {
                //conn = new SqlConnection(dbSet.AsQueryable().GetConnection().ConnectionString);
                conn = (SqlConnection)dbSet.AsQueryable().GetConnection();
            }
            conn.BulkCopyToTempTable(tmpTableName, keyList, singleColumnName);
            string sql = @"
select t.* 
from " + tableName + @" t 
inner join " + tmpTableName + @" tmp on ";

            if (singleColumnName != "")
            {
                sql += "t.[" + ((MemberExpression)singleKey.Body).Member.Name + "]=tmp.TmpColumn";
            }

            var command = new SqlCommand(sql, conn);
            command.CommandTimeout = 12000;
            command.CommandType = CommandType.Text;
            var reader = command.ExecuteReader();

            result = ParseDataReaderToEntity<TEntity>(reader);

            command.CommandText = "drop table " + tmpTableName;
            command.CommandType = System.Data.CommandType.Text;
            command.ExecuteNonQuery();

            if (!SqlConnectionManager.IsGlobalConnectionStarted)
            {
                conn.Close();
            }

            return result;
        }

        public static IList<TEntity> SelectByKeys<TEntity, TKeys, TMatchKey>(this IQueryable<TEntity> queryable, IEnumerable<TKeys> keyList, Expression<Func<TEntity, TMatchKey>> singleKey) where TEntity : class
        {
            var keyType = typeof(TKeys);
            var singleColumnName = "";
            IList<TEntity> result = new List<TEntity>();
            var resultProperties = typeof(TEntity).GetProperties();

            #region 检查参数输入
            if (keyType.IsValueType || keyType.Name.StartsWith("String"))
            {
                singleColumnName = "TmpColumn";
            }
            else
            {
                throw (new EntityException("keyList参数必须是基础类型的列表。"));
            }

            if (singleKey.Body.NodeType != ExpressionType.MemberAccess)
            {
                throw (new EntityException("singleKey参数必须是MemberAccess类型的Expression"));
            }
            #endregion

            var tableGuid = Guid.NewGuid().ToString().Replace("-", "");
            var columnString = tableGuid.Substring(10, 4);
            string tmpTableName = "##SelectTemp" + Guid.NewGuid().ToString().Replace("-", "");
            SqlConnection conn;

            if (SqlConnectionManager.IsGlobalConnectionStarted)
            {
                conn = SqlConnectionManager.GetConnection(queryable.GetConnectionKey());
            }
            else
            {
                //conn = new SqlConnection(queryable.GetConnection().ConnectionString);
                conn = (SqlConnection)queryable.GetConnection();
            }
            var parameters = queryable.GetParamters();

            singleColumnName = singleColumnName + columnString;

            conn.BulkCopyToTempTable(tmpTableName, keyList, singleColumnName);
            string sql = @"
select t.* 
from (
    " + queryable.ToString() + @"
) t 
inner join " + tmpTableName + @" tmp on ";

            if (singleColumnName != "")
            {
                sql += "t.[" + ((MemberExpression)singleKey.Body).Member.Name + "]=tmp." + singleColumnName;
            }

            var command = new SqlCommand(sql, conn);
            command.CommandTimeout = 12000;
            command.CommandType = CommandType.Text;

            foreach (var parameter in parameters)
            {
                SqlParameter sqlParameter = new SqlParameter();
                sqlParameter.ParameterName = parameter.Name;
                sqlParameter.Value = parameter.Value;
                command.Parameters.Add(sqlParameter);
            }
            var reader = command.ExecuteReader();

            result = ParseDataReaderToEntity<TEntity>(queryable.Expression, reader);

            command.CommandText = "drop table " + tmpTableName;
            command.CommandType = System.Data.CommandType.Text;
            command.ExecuteNonQuery();

            if (!SqlConnectionManager.IsGlobalConnectionStarted)
            {
                conn.Close();
            }

            return result;
        }

        public static IList<TEntity> SelectByKeys<TEntity, TKeys, TMatchKey>(this DbSet<TEntity> dbSet, SqlConnection db,
            IEnumerable<TKeys> keyList, Expression<Func<TEntity, TMatchKey>> singleKey) where TEntity : class
        {
            var keyType = typeof(TKeys);
            string tableName = typeof(TEntity).Name;
            var singleColumnName = "";
            IList<TEntity> result = new List<TEntity>();
            var resultProperties = typeof(TEntity).GetProperties();

            #region 检查参数输入
            if (keyType.IsValueType || keyType.Name.StartsWith("String"))
            {
                singleColumnName = "TmpColumn";
            }
            else
            {
                throw (new EntityException("keyList参数必须是基础类型的列表。"));
            }

            if (singleKey.Body.NodeType != ExpressionType.MemberAccess)
            {
                throw (new EntityException("singleKey参数必须是MemberAccess类型的Expression"));
            }
            #endregion

            string tmpTableName = "##SelectTemp" + Guid.NewGuid().ToString().Replace("-", "");
            db.BulkCopyToTempTable(tmpTableName, keyList, singleColumnName);
            string sql = @"
select t.* 
from " + tableName + @" t 
inner join " + tmpTableName + @" tmp on ";

            if (singleColumnName != "")
            {
                sql += "t.[" + ((MemberExpression)singleKey.Body).Member.Name + "]=tmp.TmpColumn";
            }

            var command = new SqlCommand(sql, db);
            command.CommandTimeout = 12000;
            command.CommandType = CommandType.Text;
            var reader = command.ExecuteReader();

            result = ParseDataReaderToEntity<TEntity>(reader);

            command.CommandText = "drop table " + tmpTableName;
            command.CommandType = System.Data.CommandType.Text;
            command.ExecuteNonQuery();

            return result;
        }

        /// <summary>
        /// 批次更新
        /// </summary>
        //public static int Update<TEntity>(this DbContext db, Expression<Func<TEntity, TEntity>> setExpression, Expression<Func<TEntity, bool>> whereExpression) where TEntity : class
        //{
        //    var context = ((IObjectContextAdapter)db).ObjectContext;
        //    IObjectSet<TEntity> source = context.CreateObjectSet<TEntity>();
        //    return source.Update(whereExpression, setExpression);
        //    //return source.Update(setExpression, whereExpression);
        //}

        //public static void CommitWithoutValidate(this DbContext db)
        //{
        //    db.Configuration.ValidateOnSaveEnabled = false;
        //    db.SaveChanges();
        //    db.Configuration.ValidateOnSaveEnabled = true;
        //}

        ///// <summary>
        ///// 批量更新
        ///// </summary>
        ///// <typeparam name="TEntity"></typeparam>
        ///// <typeparam name="TField"></typeparam>
        ///// <typeparam name="TKey"></typeparam>
        ///// <param name="uow"></param>
        ///// <param name="data"></param>
        ///// <param name="fields"></param>
        ///// <param name="keys"></param>
        //public static void Update<TEntity, TField, TKey>(this DbContext db, IList<TEntity> data, Expression<Func<TEntity, TField>> fields,
        //    Expression<Func<TEntity, TKey>> keys) where TEntity : class
        //{
        //    string setField = "";
        //    string keyExpression = "";
        //    string tableName = typeof(TEntity).Name;

        //    if (fields.Body.NodeType != ExpressionType.MemberAccess && fields.Body.NodeType != ExpressionType.MemberInit && fields.Body.NodeType != ExpressionType.New)
        //    {
        //        throw (new EntityException("fields参数必须是MemberAccess、MemberInit或New类型的Expression"));
        //    }

        //    if (keys.Body.NodeType != ExpressionType.MemberAccess && keys.Body.NodeType != ExpressionType.MemberInit && keys.Body.NodeType != ExpressionType.New)
        //    {
        //        throw (new EntityException("keys参数必须是MemberAccess、MemberInit或New类型的Expression"));
        //    }

        //    if (fields.Body.NodeType != ExpressionType.MemberAccess)
        //    {
        //        foreach (var bindingMember in ((NewExpression)fields.Body).Members)
        //        {
        //            if (bindingMember.MemberType == System.Reflection.MemberTypes.Property)
        //            {
        //                if (((System.Reflection.PropertyInfo)(bindingMember)).PropertyType.IsValueType
        //                    || ((System.Reflection.PropertyInfo)(bindingMember)).PropertyType.Name.StartsWith("String"))
        //                {
        //                    var field = bindingMember.Name;

        //                    if (setField != "")
        //                    {
        //                        setField += ",";
        //                    }

        //                    setField += "[" + field + "]" + "=dest.[" + field + "]";
        //                }
        //            }
        //        }
        //    }
        //    else
        //    {
        //        if (((MemberExpression)fields.Body).Member.MemberType == System.Reflection.MemberTypes.Property)
        //        {
        //            var propertyInfo = ((System.Reflection.PropertyInfo)((MemberExpression)fields.Body).Member);
        //            if (propertyInfo.PropertyType.IsValueType || propertyInfo.PropertyType.Name.StartsWith("String"))
        //            {
        //                setField = "[" + propertyInfo.Name + "]" + "=dest.[" + propertyInfo.Name + "]";
        //            }
        //        }
        //    }

        //    if (keys.Body.NodeType != ExpressionType.MemberAccess)
        //    {
        //        foreach (var bindingMember in ((NewExpression)keys.Body).Members)
        //        {
        //            if (bindingMember.MemberType == System.Reflection.MemberTypes.Property)
        //            {
        //                if (((System.Reflection.PropertyInfo)(bindingMember)).PropertyType.IsValueType
        //                    || ((System.Reflection.PropertyInfo)(bindingMember)).PropertyType.Name.StartsWith("String"))
        //                {
        //                    var key = bindingMember.Name;

        //                    if (keyExpression != "")
        //                    {
        //                        keyExpression += " and ";
        //                    }

        //                    keyExpression += "source.[" + key + "]" + "=dest.[" + key + "]";
        //                }
        //            }
        //        }
        //    }
        //    else
        //    {
        //        if (((MemberExpression)keys.Body).Member.MemberType == System.Reflection.MemberTypes.Property)
        //        {
        //            var propertyInfo = ((System.Reflection.PropertyInfo)((MemberExpression)keys.Body).Member);
        //            if (propertyInfo.PropertyType.IsValueType || propertyInfo.PropertyType.Name.StartsWith("String"))
        //            {
        //                keyExpression = "source.[" + propertyInfo.Name + "]" + "=dest.[" + propertyInfo.Name + "]";
        //            }
        //        }
        //    }

        //    string tmpTableName = "##UpdateTemp" + Guid.NewGuid().ToString().Replace("-", "");

        //    SqlConnection conn;

        //    if (SqlConnectionManager.IsGlobalConnectionStarted)
        //    {
        //        conn = SqlConnectionManager.GetConnection(db.GetDbConnectionKey());
        //    }
        //    else
        //    {
        //        conn = new SqlConnection(db.Database.Connection.ConnectionString);
        //    }
        //    conn.BulkCopyToTempTable(tmpTableName, data);

        //    string sql = @"update " + tableName + @" set " + setField + @" from " + tableName + @" source inner join " + tmpTableName + @" dest on " + keyExpression;

        //    var command = new SqlCommand(sql, conn);
        //    command.CommandTimeout = 12000;
        //    command.CommandType = System.Data.CommandType.Text;
        //    command.ExecuteNonQuery();

        //    try
        //    {
        //        command.CommandText = "drop table " + tmpTableName;
        //        command.CommandType = System.Data.CommandType.Text;
        //        command.ExecuteNonQuery();
        //    }
        //    catch { }

        //    if (!SqlConnectionManager.IsGlobalConnectionStarted)
        //    {
        //        conn.Close();
        //    }
        //}

        ///// <summary>
        ///// 批量更新
        ///// </summary>
        ///// <typeparam name="TEntity"></typeparam>
        ///// <typeparam name="TField"></typeparam>
        ///// <typeparam name="TKey"></typeparam>
        ///// <param name="uow"></param>
        ///// <param name="data"></param>
        ///// <param name="fields"></param>
        ///// <param name="keys"></param>
        //public static void Update<TEntity, TField, TKey>(this SqlConnection db, IList<TEntity> data, Expression<Func<TEntity, TField>> fields,
        //    Expression<Func<TEntity, TKey>> keys) where TEntity : class
        //{
        //    string setField = "";
        //    string keyExpression = "";
        //    string tableName = typeof(TEntity).Name;

        //    if (fields.Body.NodeType != ExpressionType.MemberAccess && fields.Body.NodeType != ExpressionType.MemberInit && fields.Body.NodeType != ExpressionType.New)
        //    {
        //        throw (new EntityException("fields参数必须是MemberAccess、MemberInit或New类型的Expression"));
        //    }

        //    if (keys.Body.NodeType != ExpressionType.MemberAccess && keys.Body.NodeType != ExpressionType.MemberInit && keys.Body.NodeType != ExpressionType.New)
        //    {
        //        throw (new EntityException("keys参数必须是MemberAccess、MemberInit或New类型的Expression"));
        //    }

        //    if (fields.Body.NodeType != ExpressionType.MemberAccess)
        //    {
        //        foreach (var bindingMember in ((NewExpression)fields.Body).Members)
        //        {
        //            if (bindingMember.MemberType == System.Reflection.MemberTypes.Property)
        //            {
        //                if (((System.Reflection.PropertyInfo)(bindingMember)).PropertyType.IsValueType
        //                    || ((System.Reflection.PropertyInfo)(bindingMember)).PropertyType.Name.StartsWith("String"))
        //                {
        //                    var field = bindingMember.Name;

        //                    if (setField != "")
        //                    {
        //                        setField += ",";
        //                    }

        //                    setField += "[" + field + "]" + "=dest.[" + field + "]";
        //                }
        //            }
        //        }
        //    }
        //    else
        //    {
        //        if (((MemberExpression)fields.Body).Member.MemberType == System.Reflection.MemberTypes.Property)
        //        {
        //            var propertyInfo = ((System.Reflection.PropertyInfo)((MemberExpression)fields.Body).Member);
        //            if (propertyInfo.PropertyType.IsValueType || propertyInfo.PropertyType.Name.StartsWith("String"))
        //            {
        //                setField = "[" + propertyInfo.Name + "]" + "=dest.[" + propertyInfo.Name + "]";
        //            }
        //        }
        //    }

        //    if (keys.Body.NodeType != ExpressionType.MemberAccess)
        //    {
        //        foreach (var bindingMember in ((NewExpression)keys.Body).Members)
        //        {
        //            if (bindingMember.MemberType == System.Reflection.MemberTypes.Property)
        //            {
        //                if (((System.Reflection.PropertyInfo)(bindingMember)).PropertyType.IsValueType
        //                    || ((System.Reflection.PropertyInfo)(bindingMember)).PropertyType.Name.StartsWith("String"))
        //                {
        //                    var key = bindingMember.Name;

        //                    if (keyExpression != "")
        //                    {
        //                        keyExpression += " and ";
        //                    }

        //                    keyExpression += "source.[" + key + "]" + "=dest.[" + key + "]";
        //                }
        //            }
        //        }
        //    }
        //    else
        //    {
        //        if (((MemberExpression)keys.Body).Member.MemberType == System.Reflection.MemberTypes.Property)
        //        {
        //            var propertyInfo = ((System.Reflection.PropertyInfo)((MemberExpression)keys.Body).Member);
        //            if (propertyInfo.PropertyType.IsValueType || propertyInfo.PropertyType.Name.StartsWith("String"))
        //            {
        //                keyExpression = "source.[" + propertyInfo.Name + "]" + "=dest.[" + propertyInfo.Name + "]";
        //            }
        //        }
        //    }

        //    string tmpTableName = "##UpdateTemp" + Guid.NewGuid().ToString().Replace("-", "");
        //    db.BulkCopyToTempTable(tmpTableName, data);

        //    string sql = @"update " + tableName + @" set " + setField + @" from " + tableName + @" source inner join " + tmpTableName + @" dest on " + keyExpression;

        //    var command = new SqlCommand(sql, db);
        //    command.CommandTimeout = 12000;
        //    command.CommandType = System.Data.CommandType.Text;
        //    command.ExecuteNonQuery();

        //    try
        //    {
        //        command.CommandText = "drop table " + tmpTableName;
        //        command.CommandType = System.Data.CommandType.Text;
        //        command.ExecuteNonQuery();
        //    }
        //    catch { }
        //}

//        /// <summary>
//        /// 批量更新
//        /// </summary>
//        /// <typeparam name="TEntity"></typeparam>
//        /// <typeparam name="TUpdateFields"></typeparam>
//        /// <param name="db"></param>
//        /// <param name="fromCause"></param>
//        /// <param name="fields"></param>
//        public static void Update<TEntity>(this DbContext db, IQueryable<TEntity> fromCause, Expression<Func<TEntity, TEntity>> fields)
//        {
//            IList<ObjectParameter> para = new List<ObjectParameter>();
//            string sql = fromCause.ToString();
//            string setField = "";
//            string tableKey = TableKeyDictionary.GetKeyName<TEntity>();

//            if (fields.Body.NodeType != ExpressionType.MemberInit)
//            {
//                throw (new EntityException("fields参数必须是MemberInit类型的Expression"));
//            }

//            foreach (var bindingExpression in ((MemberInitExpression)fields.Body).Bindings)
//            {
//                var field = bindingExpression.Member.Name;

//                if (setField != "")
//                {
//                    setField += ",";
//                }

//                if (((System.Linq.Expressions.MemberAssignment)(bindingExpression)).Expression.NodeType == ExpressionType.MemberAccess)
//                {
//                    setField += "[" + field + "]" + "=x.[" + ((MemberExpression)((System.Linq.Expressions.MemberAssignment)(bindingExpression)).Expression).Member.Name + "]";
//                }
//                else
//                {
//                    var obj = Expression.Lambda(((System.Linq.Expressions.MemberAssignment)(bindingExpression)).Expression).Compile().DynamicInvoke(null);

//                    setField += "[" + field + "]" + "=@setPara" + field;
//                }
//            }

//            fromCause.GetParamters().ToList().ForEach(x => para.Add(x));
//            sql = "update " + typeof(TEntity).Name + " set " + setField + @" 
//from " + typeof(TEntity).Name + @" a 
//inner join (" + sql + ") x on a.[" + tableKey + "]=x.[" + tableKey + "]";

//            db.Database.ExecuteSqlCommand(sql, para.ToArray());
//        }

        /// <summary>
        /// 批次刪除
        /// </summary>
        public static int Delete<TEntity>(this DbContext db, Expression<Func<TEntity, bool>> whereExpression) where TEntity : class
        {
            var context = ((IObjectContextAdapter)db).ObjectContext;
            IObjectSet<TEntity> source = context.CreateObjectSet<TEntity>();
            return source.Delete(whereExpression);
        }

        public static void Delete(this SqlConnection db, string tableName, string keyName, object keyValue)
        {
            var initState = db.State;
            if (initState == ConnectionState.Closed)
            {
                db.Open();
            }
            var sql = @"delete from " + tableName + " where " + keyName + "=@keyValue";
            var command = new SqlCommand(sql, db);
            command.CommandTimeout = 12000;
            command.CommandType = System.Data.CommandType.Text;
            command.Parameters.Add("@keyValue", SqlDbType.UniqueIdentifier);
            command.Parameters[0].IsNullable = true;
            command.Parameters[0].Value = keyValue;
            command.ExecuteNonQuery();
            if (initState == ConnectionState.Closed)
            {
                db.Close();
            }
        }

        public static List<string> GetTableColumns(this SqlConnection db, string tableName)
        {
            var initState = db.State;
            if (initState == ConnectionState.Closed)
            {
                db.Open();
            }
            var sql = @"
select * from syscolumns c 
inner join sysobjects o on c.id=o.id 
where o.xtype='U' and o.name='" + tableName + @"' 
order by colid";

            var da = new SqlDataAdapter(sql, db);

            DataTable dt = new DataTable();
            da.Fill(dt);

            if (initState == ConnectionState.Closed)
            {
                db.Close();
            }

            return dt.AsEnumerable().Select(x => x.Field<string>("name")).ToList();
        }

        //public static void Delete<TEntity>(this DbContext db, TEntity entity) where TEntity : class
        //{
        //    var typeOfEntity = typeof(TEntity);
        //    var mappingClass = typeOfEntity.Assembly.GetTypes().Where(x => x.Name == typeOfEntity.Name + "_Mapping").FirstOrDefault();
        //    var tableKeyName = TableKeyDictionary.GetKeyName(entity);
        //    var keyProperty = typeOfEntity.GetProperty(tableKeyName);
        //    var tracker = db.ChangeTracker.Entries<TEntity>().Where(x => keyProperty.GetValue(x.Entity, null) == keyProperty.GetValue(entity, null)).FirstOrDefault();

        //    if (tracker != null)
        //    {
        //        db.Set<TEntity>().Remove(tracker.Entity);
        //    }
        //    else
        //    {
        //        db.Set<TEntity>().Attach(entity);
        //        db.Set<TEntity>().Remove(entity);
        //    }
        //}

        //public static void InsertBatch<TEntity>(this IList<TEntity> data) where TEntity : class
        //{
        //    var db = GetConnections<TEntity>();

        //    data.ExecuteBulkCopy(db, typeof(TEntity).Name);
        //}

        public static SqlConnection GetConnections<TEntity>()
        {
            var blAssembly = Assembly.GetExecutingAssembly();
            var entityType = typeof(TEntity);

            if (entityType.BaseType != typeof(object))
            {
                entityType = entityType.BaseType;
            }
            var myClass = blAssembly.GetTypes()
                    .Where(x => x.Name.EndsWith("Repository") &&
                        x.BaseType.GetGenericArguments()[0].FullName == entityType.FullName)
                    .FirstOrDefault();

            string connectionKey = "";
            var context = myClass.BaseType.GetGenericArguments()[0].Assembly.GetTypes().Where(x => x.BaseType == typeof(DbContext)).FirstOrDefault();
            connectionKey = context.Name;

            if (SqlConnectionManager.IsGlobalConnectionStarted)
            {
                return SqlConnectionManager.GetConnection(connectionKey);
            }
            else
            {
                return new SqlConnection(ConfigurationManager.ConnectionStrings[connectionKey].ConnectionString);
            }
        }

        public static PropertyInfo GetPK(this EntityObject value)
        {
            //var metadata = ((IObjectContextAdapter)this).ObjectContext.MetadataWorkspace;
            //var a = metadata.GetItems(DataSpace.OSpace);
            return null;
        }

    }
}