using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Text;
using XCode.Configuration;
using XCode.DataAccessLayer;
using XCode.Exceptions;

#if NET4
using System.Linq;
#else
using NewLife.Linq;
#endif

namespace XCode
{
    /// <summary>实体持久化接口。可通过实现该接口来自定义实体类持久化行为。</summary>
    public interface IEntityPersistence
    {
        #region 添删改方法
        /// <summary>插入</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Int32 Insert(IEntity entity);

        /// <summary>更新</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Int32 Update(IEntity entity);

        /// <summary>删除</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Int32 Delete(IEntity entity);

        /// <summary>把一个实体对象持久化到数据库</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="names">更新属性列表</param>
        /// <param name="values">更新值列表</param>
        /// <returns>返回受影响的行数</returns>
        Int32 Insert(Type entityType, String[] names, Object[] values);

        /// <summary>更新一批实体数据</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="setClause">要更新的项和数据</param>
        /// <param name="whereClause">指定要更新的实体</param>
        /// <returns></returns>
        Int32 Update(Type entityType, String setClause, String whereClause);

        /// <summary>更新一批实体数据</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="setNames">更新属性列表</param>
        /// <param name="setValues">更新值列表</param>
        /// <param name="whereNames">条件属性列表</param>
        /// <param name="whereValues">条件值列表</param>
        /// <returns>返回受影响的行数</returns>
        Int32 Update(Type entityType, String[] setNames, Object[] setValues, String[] whereNames, Object[] whereValues);

        /// <summary>从数据库中删除指定条件的实体对象。</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="whereClause">限制条件</param>
        /// <returns></returns>
        Int32 Delete(Type entityType, String whereClause);

        /// <summary>从数据库中删除指定属性列表和值列表所限定的实体对象。</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="names">属性列表</param>
        /// <param name="values">值列表</param>
        /// <returns></returns>
        Int32 Delete(Type entityType, String[] names, Object[] values);
        #endregion

        #region 获取语句
        /// <summary>获取主键条件</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        String GetPrimaryCondition(IEntity entity);

        /// <summary>把SQL模版格式化为SQL语句</summary>
        /// <param name="entity">实体对象</param>
        /// <param name="methodType"></param>
        /// <returns>SQL字符串</returns>
        String GetSql(IEntity entity, DataObjectMethodType methodType);
        #endregion

        //#region 事件
        ///// <summary>设置实体Guid之前触发事件，通过Cancel控制是否取消Guid的自动设置</summary>
        //event EventHandler<EntityPersistEventArgs> OnSetGuid;

        ///// <summary>插入自增之前触发事件，通过Cancel控制是否插入自增</summary>
        //event EventHandler<EntityPersistEventArgs> OnInsertIdentity;
        //#endregion
    }

    /// <summary>默认实体持久化</summary>
    public class EntityPersistence : IEntityPersistence
    {
        //#region 事件
        ///// <summary>设置实体Guid之前触发事件，通过Cancel控制是否取消Guid的自动设置</summary>
        //public event EventHandler<EntityPersistEventArgs> OnSetGuid;

        //Boolean AllowSetGuid(IEntity entity)
        //{
        //    if (OnSetGuid != null)
        //    {
        //        var e = new EntityPersistEventArgs() { Entity = entity };
        //        OnSetGuid(this, e);
        //        return !e.Cancel;
        //    }
        //    return false;
        //}

        ///// <summary>插入自增之前触发事件，通过Cancel控制是否插入自增</summary>
        //public event EventHandler<EntityPersistEventArgs> OnInsertIdentity;

        //Boolean AllowInsertIdentity(IEntity entity)
        //{
        //    if (OnInsertIdentity != null)
        //    {
        //        var e = new EntityPersistEventArgs() { Entity = entity };
        //        OnInsertIdentity(this, e);
        //        return !e.Cancel;
        //    }
        //    return false;
        //}
        //#endregion

        #region 添删改方法
        /// <summary>插入</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual Int32 Insert(IEntity entity)
        {
            var op = EntityFactory.CreateOperate(entity.GetType());

            // 添加数据前，处理Guid
            var fi = op.AutoSetGuidField;
            if (fi != null)
            {
                //SetGuid(entity);

                // 判断是否设置了数据
                if (!entity.Dirtys[fi.Name])
                {
                    // 如果没有设置，这里给它设置
                    if (fi.Type == typeof(Guid))
                        entity.SetItem(fi.Name, Guid.NewGuid());
                    else
                        entity.SetItem(fi.Name, Guid.NewGuid().ToString());
                }
            }

            DbParameter[] dps = null;
            var sql = SQL(entity, DataObjectMethodType.Insert, ref dps);
            if (String.IsNullOrEmpty(sql)) return 0;

            Int32 rs = 0;

            //检查是否有标识列，标识列需要特殊处理
            var field = op.Table.Identity;
            var bAllow = op.AllowInsertIdentity;
            if (field != null && field.IsIdentity && !bAllow)
            {
                Int64 res = dps != null && dps.Length > 0 ? op.InsertAndGetIdentity(sql, CommandType.Text, dps) : op.InsertAndGetIdentity(sql);
                if (res > 0) entity[field.Name] = res;
                rs = res > 0 ? 1 : 0;
            }
            else
            {
                if (bAllow)
                {
                    var dal = DAL.Create(op.ConnName);
                    if (dal.DbType == DatabaseType.SqlServer)
                    {
                        // 如果所有字段都不是自增，则取消对自增的处理
                        if (op.Fields.All(f => !f.IsIdentity)) bAllow = false;
                        if (bAllow) sql = String.Format("SET IDENTITY_INSERT {1} ON;{0};SET IDENTITY_INSERT {1} OFF", sql, op.FormatName(op.TableName));
                    }
                }
                rs = dps != null && dps.Length > 0 ? op.Execute(sql, CommandType.Text, dps) : op.Execute(sql);
            }

            //清除脏数据，避免连续两次调用Save造成重复提交
            if (entity.Dirtys != null) entity.Dirtys.Clear();

            return rs;
        }

        /// <summary>更新</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual Int32 Update(IEntity entity)
        {
            //没有脏数据，不需要更新
            if (entity.Dirtys == null || entity.Dirtys.Count <= 0) return 0;

            DbParameter[] dps = null;
            String sql = SQL(entity, DataObjectMethodType.Update, ref dps);
            if (String.IsNullOrEmpty(sql)) return 0;

            IEntityOperate op = EntityFactory.CreateOperate(entity.GetType());
            Int32 rs = dps != null && dps.Length > 0 ? op.Execute(sql, CommandType.Text, dps) : op.Execute(sql);

            //清除脏数据，避免重复提交
            if (entity.Dirtys != null) entity.Dirtys.Clear();

            entity.ClearAdditionalValues();

            return rs;
        }

        /// <summary>删除</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual Int32 Delete(IEntity entity)
        {
            IEntityOperate op = EntityFactory.CreateOperate(entity.GetType());

            String sql = DefaultCondition(entity);
            if (String.IsNullOrEmpty(sql)) return 0;

            return op.Execute(String.Format("Delete From {0} Where {1}", op.FormatName(op.TableName), sql));
        }

        /// <summary>把一个实体对象持久化到数据库</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="names">更新属性列表</param>
        /// <param name="values">更新值列表</param>
        /// <returns>返回受影响的行数</returns>
        public virtual Int32 Insert(Type entityType, String[] names, Object[] values)
        {
            if (names == null) throw new ArgumentNullException("names", "属性列表和值列表不能为空");
            if (values == null) throw new ArgumentNullException("values", "属性列表和值列表不能为空");
            if (names.Length != values.Length) throw new ArgumentException("属性列表必须和值列表一一对应");

            IEntityOperate op = EntityFactory.CreateOperate(entityType);

            Dictionary<String, FieldItem> fs = new Dictionary<String, FieldItem>(StringComparer.OrdinalIgnoreCase);
            foreach (FieldItem fi in op.Fields)
                fs.Add(fi.Name, fi);
            StringBuilder sbn = new StringBuilder();
            StringBuilder sbv = new StringBuilder();
            for (Int32 i = 0; i < names.Length; i++)
            {
                if (!fs.ContainsKey(names[i])) throw new ArgumentException("类[" + entityType.FullName + "]中不存在[" + names[i] + "]属性");
                // 同时构造SQL语句。names是属性列表，必须转换成对应的字段列表
                if (i > 0)
                {
                    sbn.Append(", ");
                    sbv.Append(", ");
                }
                sbn.Append(op.FormatName(fs[names[i]].Name));
                //sbv.Append(SqlDataFormat(values[i], fs[names[i]]));
                sbv.Append(op.FormatValue(names[i], values[i]));
            }
            return op.Execute(String.Format("Insert Into {2}({0}) values({1})", sbn.ToString(), sbv.ToString(), op.FormatName(op.TableName)));
        }

        /// <summary>更新一批实体数据</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="setClause">要更新的项和数据</param>
        /// <param name="whereClause">指定要更新的实体</param>
        /// <returns></returns>
        public virtual Int32 Update(Type entityType, String setClause, String whereClause)
        {
            if (String.IsNullOrEmpty(setClause) || !setClause.Contains("=")) throw new ArgumentException("非法参数");

            IEntityOperate op = EntityFactory.CreateOperate(entityType);
            String sql = String.Format("Update {0} Set {1}", op.FormatName(op.TableName), setClause);
            if (!String.IsNullOrEmpty(whereClause)) sql += " Where " + whereClause;
            return op.Execute(sql);
        }

        /// <summary>更新一批实体数据</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="setNames">更新属性列表</param>
        /// <param name="setValues">更新值列表</param>
        /// <param name="whereNames">条件属性列表</param>
        /// <param name="whereValues">条件值列表</param>
        /// <returns>返回受影响的行数</returns>
        public virtual Int32 Update(Type entityType, String[] setNames, Object[] setValues, String[] whereNames, Object[] whereValues)
        {
            IEntityOperate op = EntityFactory.CreateOperate(entityType);

            String sc = op.MakeCondition(setNames, setValues, ", ");
            String wc = op.MakeCondition(whereNames, whereValues, " And ");
            return Update(entityType, sc, wc);
        }

        /// <summary>从数据库中删除指定条件的实体对象。</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="whereClause">限制条件</param>
        /// <returns></returns>
        public virtual Int32 Delete(Type entityType, String whereClause)
        {
            IEntityOperate op = EntityFactory.CreateOperate(entityType);

            String sql = String.Format("Delete From {0}", op.FormatName(op.TableName));
            if (!String.IsNullOrEmpty(whereClause)) sql += " Where " + whereClause;
            return op.Execute(sql);
        }

        /// <summary>从数据库中删除指定属性列表和值列表所限定的实体对象。</summary>
        /// <param name="entityType">实体类</param>
        /// <param name="names">属性列表</param>
        /// <param name="values">值列表</param>
        /// <returns></returns>
        public virtual Int32 Delete(Type entityType, String[] names, Object[] values)
        {
            IEntityOperate op = EntityFactory.CreateOperate(entityType);

            return Delete(entityType, op.MakeCondition(names, values, "And"));
        }
        #endregion

        #region 获取语句
        /// <summary>把SQL模版格式化为SQL语句</summary>
        /// <param name="entity">实体对象</param>
        /// <param name="methodType"></param>
        /// <returns>SQL字符串</returns>
        public virtual String GetSql(IEntity entity, DataObjectMethodType methodType) { DbParameter[] dps = null; return SQL(entity, methodType, ref dps); }

        /// <summary>把SQL模版格式化为SQL语句</summary>
        /// <param name="entity">实体对象</param>
        /// <param name="methodType"></param>
        /// <param name="parameters"></param>
        /// <returns>SQL字符串</returns>
        String SQL(IEntity entity, DataObjectMethodType methodType, ref DbParameter[] parameters)
        {
            IEntityOperate op = EntityFactory.CreateOperate(entity.GetType());

            String sql;
            StringBuilder sbNames;
            StringBuilder sbValues;

            // sbParams用于存储参数化操作时格式化的参数名，参数化和非参数化同时使用，如果存在大字段是，才使用参数化
            //StringBuilder sbParams;
            List<DbParameter> dps;
            //Boolean hasBigField = false;

            Boolean isFirst = true;
            switch (methodType)
            {
                case DataObjectMethodType.Fill:
                    return String.Format("Select * From {0}", op.FormatName(op.TableName));
                case DataObjectMethodType.Select:
                    sql = DefaultCondition(entity);
                    // 没有标识列和主键，返回取所有数据的语句
                    if (String.IsNullOrEmpty(sql)) throw new XCodeException("实体类缺少主键！");
                    return String.Format("Select * From {0} Where {1}", op.FormatName(op.TableName), sql);
                case DataObjectMethodType.Insert:
                    #region Insert
                    sbNames = new StringBuilder();
                    sbValues = new StringBuilder();
                    //sbParams = new StringBuilder();
                    dps = new List<DbParameter>();
                    // 只读列没有插入操作
                    foreach (var fi in op.Fields)
                    {
                        // 标识列不需要插入，别的类型都需要
                        String idv = null;
                        if (fi.IsIdentity)
                        {
                            if (op.AllowInsertIdentity)
                                idv = "" + entity[fi.Name];
                            else
                                idv = DAL.Create(op.ConnName).Db.FormatIdentity(fi.Field, entity[fi.Name]);
                            //if (String.IsNullOrEmpty(idv)) continue;
                            // 允许返回String.Empty作为插入空
                            if (idv == null) continue;
                        }

                        // 有默认值，并且没有设置值时，不参与插入操作
                        // 20120509增加，同时还得判断是否相同数据库或者数据库默认值，比如MSSQL数据库默认值不是GetDate，那么其它数据库是不可能使用的
                        if (!String.IsNullOrEmpty(fi.DefaultValue) && !entity.Dirtys[fi.Name] && CanUseDefault(fi, op)) continue;

                        if (!isFirst) sbNames.Append(", ");
                        var name = op.FormatName(fi.ColumnName);
                        sbNames.Append(name);
                        if (!isFirst)
                            sbValues.Append(", ");
                        else
                            isFirst = false;

                        //// 可空类型插入空
                        //if (!obj.Dirtys[fi.Name] && fi.DataObjectField.IsNullable)
                        //    sbValues.Append("null");
                        //else
                        //sbValues.Append(SqlDataFormat(obj[fi.Name], fi)); // 数据

                        if (!fi.IsIdentity)
                        {
                            if (!UseParam(fi))
                                sbValues.Append(op.FormatValue(fi, entity[fi.Name]));
                            else
                            {
                                var paraname = op.FormatParameterName(fi.ColumnName);
                                sbValues.Append(paraname);

                                var dp = op.CreateParameter();
                                dp.ParameterName = paraname;
                                //dp.Value = entity[fi.Name] ?? DBNull.Value;
                                dp.Value = FormatParamValue(fi, entity[fi.Name], op);
                                dp.IsNullable = fi.IsNullable;
                                dps.Add(dp);
                            }
                        }
                        else
                            sbValues.Append(idv);
                    }

                    if (sbNames.Length <= 0) return null;

                    if (dps.Count > 0) parameters = dps.ToArray();
                    return String.Format("Insert Into {0}({1}) Values({2})", op.FormatName(op.TableName), sbNames, sbValues);
                    #endregion
                case DataObjectMethodType.Update:
                    #region Update
                    sbNames = new StringBuilder();
                    //sbParams = new StringBuilder();
                    dps = new List<DbParameter>();
                    // 只读列没有更新操作
                    foreach (FieldItem fi in op.Fields)
                    {
                        if (fi.IsIdentity) continue;

                        //脏数据判断
                        if (!entity.Dirtys[fi.Name]) continue;

                        if (!isFirst)
                            sbNames.Append(", "); // 加逗号
                        else
                            isFirst = false;

                        var name = op.FormatName(fi.ColumnName);
                        sbNames.Append(name);
                        sbNames.Append("=");
                        //sbNames.Append(SqlDataFormat(obj[fi.Name], fi)); // 数据

                        if (!UseParam(fi))
                        {
                            // 检查累加
                            Object addvalue = null;
                            Boolean sign;
                            if (entity.TryGetAdditionalValue(fi.Name, out addvalue, out sign))
                            {
                                if (sign)
                                    sbNames.AppendFormat("{0}+{1}", name, addvalue);
                                else
                                    sbNames.AppendFormat("{0}-{1}", name, addvalue);
                            }
                            else
                            {
                                sbNames.Append(op.FormatValue(fi, entity[fi.Name])); // 数据
                            }
                        }
                        else
                        {
                            var paraname = op.FormatParameterName(fi.ColumnName);
                            sbNames.Append(paraname);

                            var dp = op.CreateParameter();
                            dp.ParameterName = paraname;
                            dp.Value = FormatParamValue(fi, entity[fi.Name], op);
                            dp.IsNullable = fi.IsNullable;
                            dps.Add(dp);
                        }
                    }

                    if (sbNames.Length <= 0) return null;

                    sql = DefaultCondition(entity);
                    if (String.IsNullOrEmpty(sql)) return null;

                    if (dps.Count > 0) parameters = dps.ToArray();
                    return String.Format("Update {0} Set {1} Where {2}", op.FormatName(op.TableName), sbNames, sql);
                    #endregion
                case DataObjectMethodType.Delete:
                    // 标识列作为删除关键字
                    sql = DefaultCondition(entity);
                    if (String.IsNullOrEmpty(sql))
                        return null;
                    return String.Format("Delete From {0} Where {1}", op.FormatName(op.TableName), sql);
            }
            return null;
        }

        static Boolean UseParam(FieldItem fi)
        {
            return (fi.Length <= 0 || fi.Length >= 4000) && (fi.Type == typeof(Byte[]) || fi.Type == typeof(String));
        }

        static Object FormatParamValue(FieldItem fi, Object value, IEntityOperate eop)
        {
            if (value != null) return value;

            if (fi.IsNullable) return DBNull.Value;

            switch (Type.GetTypeCode(fi.Type))
            {
                case TypeCode.Boolean:
                    return false;
                case TypeCode.DBNull:
                case TypeCode.Empty:
                    return DBNull.Value;
                case TypeCode.DateTime:
                    return DAL.Create(eop.ConnName).Db.DateTimeMin;
                case TypeCode.Byte:
                case TypeCode.Char:
                case TypeCode.Decimal:
                case TypeCode.Double:
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.SByte:
                case TypeCode.Single:
                case TypeCode.UInt16:
                case TypeCode.UInt32:
                case TypeCode.UInt64:
                    return 0;
                case TypeCode.String:
                    return String.Empty;
                default:
                    break;
            }

            return DBNull.Value;
        }

        static Boolean CanUseDefault(FieldItem fi, IEntityOperate eop)
        {
            var dbType = fi.Table.Table.DbType;
            var dal = DAL.Create(eop.ConnName);
            if (dbType == dal.DbType) return true;

            // 原始数据库类型
            var db = DbFactory.Create(dbType);
            if (db == null) return false;

            var tc = Type.GetTypeCode(fi.Type);
            // 特殊处理时间
            if (tc == TypeCode.DateTime)
            {
                if (String.Equals(db.DateTimeNow, fi.DefaultValue, StringComparison.OrdinalIgnoreCase)) return true;
            }

            return false;
        }

        /// <summary>获取主键条件</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual String GetPrimaryCondition(IEntity entity) { return DefaultCondition(entity); }

        /// <summary>
        /// 默认条件。
        /// 若有标识列，则使用一个标识列作为条件；
        /// 如有主键，则使用全部主键作为条件。
        /// </summary>
        /// <param name="entity">实体对象</param>
        /// <returns>条件</returns>
        static String DefaultCondition(IEntity entity)
        {
            IEntityOperate op = EntityFactory.CreateOperate(entity.GetType());

            // 标识列作为查询关键字
            FieldItem fi = op.Table.Identity;
            if (fi != null) return op.MakeCondition(fi, entity[fi.Name], "=");

            // 主键作为查询关键字
            FieldItem[] ps = op.Table.PrimaryKeys;
            // 没有标识列和主键，返回取所有数据的语句
            if (ps == null || ps.Length < 1)
            {
                if (DAL.Debug) throw new XCodeException("因为没有主键，无法给实体类构造默认条件！");
                return null;
            }

            StringBuilder sb = new StringBuilder();
            foreach (FieldItem item in ps)
            {
                if (sb.Length > 0) sb.Append(" And ");
                sb.Append(op.FormatName(item.ColumnName));
                sb.Append("=");
                sb.Append(op.FormatValue(item, entity[item.Name]));
            }
            return sb.ToString();
        }
        #endregion

        #region 设置Guid
        ///// <summary>指定了默认值而没有赋值的Guid字段附上默认值</summary>
        ///// <param name="entity"></param>
        //public virtual void SetGuid(IEntity entity)
        //{
        //    var fis = GetGuidFieldItems(entity.GetType());
        //    if (fis != null & fis.Length > 0)
        //    {
        //        foreach (var item in fis)
        //        {
        //            // 判断是否设置了数据
        //            if (!entity.Dirtys[item.Name])
        //            {
        //                // 如果没有设置，这里给它设置
        //                if (item.Type == typeof(Guid))
        //                    entity.SetItem(item.Name, Guid.NewGuid());
        //                else
        //                    entity.SetItem(item.Name, Guid.NewGuid().ToString());
        //            }
        //        }
        //    }
        //}

        //static DictionaryCache<Type, FieldItem[]> _guidFields = new DictionaryCache<Type, FieldItem[]>();
        ///// <summary>找到设定了默认值的Guid字段</summary>
        ///// <param name="type"></param>
        ///// <returns></returns>
        //protected static FieldItem[] GetGuidFieldItems(Type type)
        //{
        //    return _guidFields.GetItem(type, key =>
        //    {
        //        var eop = EntityFactory.CreateOperate(key);
        //        // 只检查默认设计的数据库
        //        var db = DbFactory.Create(eop.Table.DataTable.DbType);
        //        if (String.IsNullOrEmpty(db.NewGuid)) return null;

        //        var list = new List<FieldItem>();
        //        foreach (var item in eop.AllFields)
        //        {
        //            //if (String.IsNullOrEmpty(item.DefaultValue)) continue;

        //            var tc = Type.GetTypeCode(item.Type);
        //            if (tc == TypeCode.String)
        //            {
        //                if (item.DefaultValue.EqualIgnoreCase(db.NewGuid)) list.Add(item);
        //            }
        //            else if (item.Type == typeof(Guid))
        //            {
        //                if (item.DefaultValue.EqualIgnoreCase(db.NewGuid) || String.IsNullOrEmpty(item.DefaultValue)) list.Add(item);
        //            }
        //        }
        //        return list.ToArray();
        //    });
        //}
        #endregion
    }

    //public class EntityPersistEventArgs : EventArgs
    //{
    //    private IEntity _Entity;
    //    /// <summary>实体</summary>
    //    public IEntity Entity { get { return _Entity; } set { _Entity = value; } }

    //    private Boolean _Cancel;
    //    /// <summary>是否取消</summary>
    //    public Boolean Cancel { get { return _Cancel; } set { _Cancel = value; } }
    //}
}