using System;
using System.Collections.Generic;
using System.Collections;
using System.Reflection;
using System.Data;
using System.Text;
using Ant.Frame;
using Ant.Entity;
using System.Linq;
using Ant.DbExpressions;
using Ant.Descriptors;
using Ant.Exceptions;
using Ant.Common;

namespace Ant.ORM
{
    /// <summary>
    /// 
    /// </summary>
    public sealed class MetaDataManager
    {
        private static Dictionary<string, FiledMetaData> MetaDataChache = new Dictionary<string, FiledMetaData>();
        private static object lockHelper = new object();
        /// <summary>
        /// 获取实体的元数据
        /// </summary>
        /// <param name="enty">实体数据</param>
        /// <returns></returns>
        public static MetaData GetMetaData(object enty)
        {
            MetaData mdmod = new MetaData();
            mdmod.FiledMeta = GetMetaData(enty.GetType());//获取实体属性
            ParserMeta(enty, null, mdmod);//获取实体的值
            return mdmod;
        }
        /// <summary>
        /// 获取值和查询实体的属性和值，此方法用Update
        /// </summary>
        /// <param name="enty">需要更新的实体</param>
        /// <param name="entywhere">用于查询条件的实体</param>
        /// <returns></returns>
        public static MetaData GetMetaData(object enty, object entywhere)
        {
            MetaData mdmod = new MetaData();
            mdmod.FiledMeta = GetMetaData(enty.GetType());
            ParserMeta(enty, entywhere, mdmod);
            return mdmod;
        }
        /// <summary>
        /// 获取实体的元数据
        /// </summary>
        /// <param name="t">实体类型</param>
        /// <returns></returns>
        public static FiledMetaData GetMetaData(Type t)
        {
            MetaData md = new MetaData();
            string key = string.Format(@"{0}.{1}", t.Namespace, t.Name);
            if (!MetaDataChache.ContainsKey(key))
            {
                lock (lockHelper)
                {
                    if (!MetaDataChache.ContainsKey(key))
                    {
                        var filed = GetParserMeta(t);
                        var ll = filed.MemberColumnMap;
                        MetaDataChache.Add(key, filed);
                        //string value = "";
                        //value = "表名：" + ll.Values.FirstOrDefault().Table.Name;
                        //foreach (DbColumnAccessExpression mm in ll.Values)
                        //{
                        //    value = value + "；列名：" + mm.Column.Name;
                        //}
                        //LoggerHelper.Info(key + "的字段值：" + value + "；总列数：" + ll.Values.Count());
                    }
                }
            }
            return MetaDataChache[key];
        }
        /// <summary>
        /// 获取缓存记录
        /// </summary>
        /// <returns></returns>
        public static int GetMetaDataCount()
        {
            return MetaDataChache.Count;
        }
        /// <summary>
        /// 获取缓存数据
        /// </summary>
        /// <returns></returns>
        public static List<string> GetMetaDataList()
        {
            List<string> list = new List<string>();
            foreach (string key in MetaDataChache.Keys)
            {
                list.Add(key);
            }
            return list;
        }
        /// <summary>
        /// 移除某个缓存
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool Remove(string key)
        {
            if (MetaDataChache.ContainsKey(key))
            {
                return MetaDataChache.Remove(key);
            }
            return true;
        }
        /// <summary>
        /// 清除缓存
        /// </summary>
        /// <returns></returns>
        public static bool Clear()
        {
            MetaDataChache.Clear();
            return true;
        }


        /// <summary>
        /// 获取字段属性
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        private static FiledMetaData GetParserMeta(Type t)
        {
            FiledMetaData filed = new FiledMetaData();
            filed.EntityType = t;
            filed.Propertys = t.GetProperties(BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance);
            filed.Table = InitTableInfo(t);
            filed.Fields = new List<MemberInfo>();

            List<MappingMemberDescriptor> mappingMember = new List<MappingMemberDescriptor>();
            var pinfos = filed.Propertys;
            filed.MappingMemberDescriptors = new Dictionary<MemberInfo, MappingMemberDescriptor>(pinfos.Count());
            filed.MemberColumnMap = new Dictionary<MemberInfo, DbColumnAccessExpression>(pinfos.Count());
            foreach (PropertyInfo pinfo in pinfos)
            {
                MappingMemberDescriptor memberDescriptor = ConstructMappingMemberDescriptor(pinfo, filed);
                mappingMember.Add(memberDescriptor);

                filed.MappingMemberDescriptors.Add(memberDescriptor.MemberInfo, memberDescriptor);

                var ignoreFlags = pinfo.GetCustomAttributes(typeof(NotMappedAttribute), false);
                if (ignoreFlags.Length == 0)
                {
                    filed.MemberColumnMap.Add(memberDescriptor.MemberInfo, new DbColumnAccessExpression(filed.Table, memberDescriptor.Column));
                    filed.Fields.Add(memberDescriptor.MemberInfo);
                }
            }

            int primaryKeyCount = mappingMember.Where(a => a.IsPrimaryKey).Count();
            if (primaryKeyCount > 1)
                throw new NotSupportedException(string.Format("映射类型 '{0}'不能定义多个主键", filed.EntityType.FullName));
            else if (primaryKeyCount == 1)
            {
                filed.PrimaryKey = mappingMember.Where(a => a.IsPrimaryKey).First();
            }
            else
            {
                //如果没有定义任何主键，则从所有映射的属性中查找名为 id 的属性作为主键
                MappingMemberDescriptor idNameMemberDescriptor = mappingMember.Where(a => a.MemberInfo.Name.ToLower() == "id" && !a.IsDefined(typeof(ColumnAttribute))).FirstOrDefault();

                if (idNameMemberDescriptor != null)
                {
                    idNameMemberDescriptor.IsPrimaryKey = true;
                    filed.PrimaryKey = idNameMemberDescriptor;
                }
            }

            List<MappingMemberDescriptor> autoIncrementMemberDescriptors = mappingMember.Where(a => a.IsDefined(typeof(AutoIncrementAttribute))).ToList();
            if (autoIncrementMemberDescriptors.Count > 1)
            {
                throw new NotSupportedException(string.Format("映射类型'{0}'不能确定多个自动增量成员", filed.EntityType.FullName));
            }
            else if (autoIncrementMemberDescriptors.Count == 1)
            {
                MappingMemberDescriptor autoIncrementMemberDescriptor = autoIncrementMemberDescriptors[0];
                if (autoIncrementMemberDescriptor.IsDefined(typeof(NotAutoIncrementAttribute)))
                {
                    throw new AntORMException(string.Format("不能在相同的映射成员上定义 'AutoIncrementAttribute' 和 'NotAutoIncrementAttribute'{0}'.", autoIncrementMemberDescriptor.MemberInfo.Name));
                }

                if (!IsAutoIncrementType(autoIncrementMemberDescriptor.MemberInfoType))
                {
                    throw new AntORMException("自动增量成员类型必须是 Int16，Int32 或 Int64");
                }

                autoIncrementMemberDescriptor.IsAutoIncrement = true;
                filed.AutoIncrement = autoIncrementMemberDescriptor;
            }
            else
            {
                MappingMemberDescriptor defaultAutoIncrementMemberDescriptor = mappingMember.Where(a => a.IsPrimaryKey && IsAutoIncrementType(a.MemberInfoType) && !a.IsDefined(typeof(NotAutoIncrementAttribute))).FirstOrDefault();
                if (defaultAutoIncrementMemberDescriptor != null)
                {
                    defaultAutoIncrementMemberDescriptor.IsAutoIncrement = true;
                    filed.AutoIncrement = defaultAutoIncrementMemberDescriptor;
                }
            }

            return filed;

        }


        /// <summary>
        /// 获取实体类每个成员的属性
        /// </summary>
        /// <param name="pinfo"></param>
        /// <param name="meta"></param>
        /// <returns></returns>
        static MappingMemberDescriptor ConstructMappingMemberDescriptor(PropertyInfo pinfo, FiledMetaData meta)
        {
            string columnName = null;
            bool isPrimaryKey = false;

            var columnFlags = pinfo.GetCustomAttributes(typeof(ColumnAttribute), true);
            if (columnFlags.Length > 0)
            {
                ColumnAttribute columnFlag = columnFlags.First() as ColumnAttribute;
                if (columnFlag.Name != null)
                    columnName = columnFlag.Name;
                else
                    columnName = pinfo.Name;

                if (columnFlag.IsPrimaryKey)
                {
                    isPrimaryKey = true;
                }
            }
            else
                columnName = pinfo.Name;


            MappingMemberDescriptor memberDescriptor = null;
            PropertyInfo propertyInfo = pinfo as PropertyInfo;
            if (propertyInfo != null)
            {
                memberDescriptor = new PropertyDescriptor(propertyInfo, meta, columnName);
            }


            memberDescriptor.IsPrimaryKey = isPrimaryKey;

            return memberDescriptor;

        }



        /// <summary>
        /// 判断是否是自动增长
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        static bool IsAutoIncrementType(Type t)
        {
            return t == UtilConstants.TypeOfInt16 || t == UtilConstants.TypeOfInt32 || t == UtilConstants.TypeOfInt64 || t == UtilConstants.TypeOfIntNull16 || t == UtilConstants.TypeOfIntNull32 || t == UtilConstants.TypeOfIntNull64;
        }

        /// <summary>
        /// 是否是自动增长
        /// </summary>
        /// <param name="memberDescriptor"></param>
        /// <returns></returns>
        public static bool IsAutoIncrement(MappingMemberDescriptor memberDescriptor, MetaData md)
        {
            return md.FiledMeta.AutoIncrement == memberDescriptor;
        }

        /// <summary>
        /// 通过MemberInfo获取实体映射关系
        /// </summary>
        /// <param name="memberInfo"></param>
        /// <returns></returns>
        public static MappingMemberDescriptor TryGetMappingMemberDescriptor(MemberInfo memberInfo, FiledMetaData md)
        {
            MappingMemberDescriptor memberDescriptor;
            if (!md.MappingMemberDescriptors.TryGetValue(memberInfo, out memberDescriptor))
            {
                return null;
            }

            return memberDescriptor;
        }

        /// <summary>
        /// 通字段名获取实体映射关系
        /// </summary>
        /// <param name="memberName"></param>
        /// <returns></returns>
        public static MappingMemberDescriptor GetMappingMemberDescriptor(string memberName, FiledMetaData md)
        {
            MappingMemberDescriptor memberDescriptor;
            var memberInfo = md.Fields.Where(a => a.Name == memberName).FirstOrDefault();
            if (!md.MappingMemberDescriptors.TryGetValue(memberInfo, out memberDescriptor))
            {
                return null;
            }
            return memberDescriptor;
        }


        /// <summary>
        /// 主键是否存在
        /// </summary>
        /// <returns></returns>
        public static bool HasPrimaryKey(FiledMetaData md)
        {
            return md.PrimaryKey != null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        static DbTable InitTableInfo(Type t)
        {
            var tableFlags = t.GetCustomAttributes(typeof(TableAttribute), false);

            string tableName;
            if (tableFlags.Length > 0)
            {
                TableAttribute tableFlag = (TableAttribute)tableFlags.First();
                if (tableFlag.Name != null)
                    tableName = tableFlag.Name;
                else
                    tableName = t.Name;
            }
            else
                tableName = t.Name;

            return new DbTable(tableName);
        }

        /// <summary>
        /// 获取实体模块
        /// </summary>
        /// <param name="enty"></param>
        /// <returns></returns>
        public static dynamic GetEntityByName(object enty, string name)
        {
            PropertyInfo pinfo = enty.GetType().GetProperty(name);
            if (pinfo.IfNotNull())
            {
                var obj = pinfo.GetValue(enty, null);
                return obj;
            }
            return null;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="enty"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public static EntityPersistType GetEnumByName(object enty, string name)
        {
            PropertyInfo pinfo = enty.GetType().GetProperty(name);
            if (pinfo.IfNotNull())
            {
                var obj = pinfo.GetValue(enty, null);
                var vl = (EntityPersistType)Enum.Parse(typeof(EntityPersistType), obj.ToString());
                return vl;
            }
            return EntityPersistType.Save;
        }
        /// <summary>
        /// 对有查询条件实体来进行获取实体的属性
        /// </summary>
        /// <param name="entyvalue"></param>
        /// <param name="entywhere">UPDATE操作才会需要用，用来遍历查询实体</param>
        /// <param name="md"></param>
        /// <returns></returns>
        public static MetaData ParserMeta(object entyvalue, object entywhere, MetaData md)
        {
            var t = entyvalue.GetType();
            FieldValueCollection fields = new FieldValueCollection();//字段值
            //if (md.FieldsColumns.IsNull())
            //    md.FieldsColumns = new Dictionary<string, DbColumn>();
            //2017.11.29修改
            md.FieldsColumns = new Dictionary<string, DbColumn>();
            if (md.FiledMeta.Fields.IsNull())
                md.FiledMeta.Fields = new List<MemberInfo>();
            if (md.WhereColumns.IsNull())
                md.WhereColumns = new Dictionary<string, DbColumn>();
            //md.Values = new Dictionary<string, EntityValue>();
            //md.ModuleName = GetEntityByName(entyvalue, "ModuleName") as string;
            //md.Values = GetEntityByName(entyvalue, "Values") as Dictionary<string, EntityValue>;
            md.PersistType = GetEnumByName(entyvalue, "PersistType");
            string str = string.Empty;

            #region get fields 获取映射字段
            foreach (var kv in md.FiledMeta.MemberColumnMap)
            {
                MemberInfo member = kv.Key;
                //md.Fields.Add(member);

                MappingMemberDescriptor memberDescriptor = TryGetMappingMemberDescriptor(kv.Key, md.FiledMeta);
                var val = memberDescriptor.GetValue(entyvalue);
                str += "列名：" + member.Name + "当前值：" + val;
                if (val.IfNotNull())
                {
                    if (md.FiledMeta.MemberColumnMap.ContainsKey(kv.Key))
                    {
                        if (md.FieldsColumns.ContainsKey(kv.Key.Name))
                        {
                            var orginvalue = md.FieldsColumns[kv.Key.Name].Value;
                            str += "原始值：" + orginvalue;
                            if (orginvalue != val)
                            {
                                var column = memberDescriptor.Column;
                                column.Value = val;
                                md.FieldsColumns[kv.Key.Name] = column;
                                //md.Values = SetChanaged(memberDescriptor.Column.Name, val, md.Values);
                            }
                        }
                        else
                        {
                            var column = memberDescriptor.Column;
                            column.Value = val;
                            md.FieldsColumns.Add(kv.Key.Name, column);
                            //md.Values = SetChanaged(memberDescriptor.Column.Name, val, md.Values);
                        }
                    }

                }
                if (entywhere.IfNotNull())
                {
                    var wherevalue = memberDescriptor.GetValue(entywhere);

                    if (md.FiledMeta.MemberColumnMap.ContainsKey(kv.Key))
                    {
                        DbExpression valExp = DbExpression.Parameter(wherevalue, memberDescriptor.MemberInfoType);
                        valExp.ParameterValue = wherevalue;
                        var column = memberDescriptor.Column;
                        column.Value = wherevalue;
                        md.WhereColumns.Add(kv.Key.Name, column);//获取列值
                    }

                }

            }
            #endregion

            //LoggerHelper.Info("表名：" + md.FiledMeta.Table.Name + str);

            //md.Fields = fields;//除了update以外的查询条件//update的赋值

            return md;



        }


        /// <summary>
        /// 获取实体的操作类型
        /// </summary>
        /// <param name="enty"></param>
        /// <returns></returns>
        public static EntityPersistType GetEntityType(object enty)
        {
            PropertyInfo pinfo = enty.GetType().GetProperty("PersistType");
            if (pinfo.IfNotNull())
            {
                return (EntityPersistType)pinfo.GetValue(enty, null);
            }

            return EntityPersistType.Save;
        }
        /// <summary>
        /// 获取实体模块
        /// </summary>
        /// <param name="enty"></param>
        /// <returns></returns>
        public static string GetEntityModuleName(object enty)
        {
            PropertyInfo pinfo = enty.GetType().GetProperty("ModuleName");
            if (pinfo.IfNotNull())
            {
                return pinfo.GetValue(enty, null).ToString();
            }
            return "";
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        private static DbType GetDbType(Type s)
        {
            DbType dbType;
            switch (s.Name)
            {
                case "String":
                    dbType = DbType.String;
                    break;
                case "Int32":
                    dbType = DbType.Int32;
                    break;
                case "Int16":
                    dbType = DbType.Int16;
                    break;
                case "Double":
                    dbType = DbType.Double;
                    break;
                case "Boolean":
                    dbType = DbType.Boolean;
                    break;
                case "DateTime":
                    dbType = DbType.DateTime;
                    break;
                default:
                    dbType = DbType.String;
                    break;
            }
            return dbType;

        }
    }
}