using System;
using System.CodeDom;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
 
namespace DbGenerator
{
    public class EFCodeWriterDataContractInfo
    {
        public string Namespace { get; set; }
 
        public bool IsDataMemberRequired { get; set; }
 
        public bool IsReferencesInDataContract { get; set; }
    }
 
    public class EFCodeWriterNewtonsoftJsonInfo
    {
        public bool IsReferencesInDataContract { get; set; }
    }
 
    public class EFCodeWriterPropertyChangedInfo
    {
        public string MethodName { get; set; }
 
        public EFCodeWriterPropertyChangedInfo()
        {
            MethodName = "OnPropertyChanged";
        }
    }
 
    public class EFCodeWriter : ICodeWriter
    {
        #region Configuration
 
        public string RequiredMessageConstName { get; set; }
 
        public string RequiredMessage { get; set; }
 
        public string MaxTextLengthMessageConstName { get; set; }
 
        public string MaxTextLengthMessage { get; set; }
 
        public event Action<CodeNamespaceImportCollection> ConvertImports = delegate { };
 
 
        public string ContextClassName { get; set; }
 
        public string TableQueryTypeName { get; set; }
 
        public string TableQueryFactoryMethodName { get; set; }
 
        public bool IsOnModelCreatingInternalInvoke { get; set; }
 
        public string GetPropertyNameExpressionPattern { get; set; }
 
 
        public EFCodeWriterDataContractInfo DataContract { get; set; }
 
        public EFCodeWriterNewtonsoftJsonInfo NewtonsoftJson { get; set; }
 
        public EFCodeWriterPropertyChangedInfo PropertyChanged { get; set; }
 
 
        public string CollectionType { get; set; }
 
        public string ReferencePropertyNamePattern { get; set; }
 
        public string BackReferencePropertyNamePattern { get; set; }
 
 
        public EFCodeWriter()
        {
            RequiredMessageConstName = "RequiredMessage";
            RequiredMessage = "Не указано обязательное поле {0}.";
 
            MaxTextLengthMessageConstName = "MaxTextLengthMessage";
            MaxTextLengthMessage = "Превышена максимальная длина строки {1} символов в поле {0}.";
 
            TableQueryTypeName = "IDbSet";
            TableQueryFactoryMethodName = "SetEx";
            GetPropertyNameExpressionPattern = "p => p.{0}";
 
            CollectionType = "List";
            ReferencePropertyNamePattern = "{0}_Reference";
            BackReferencePropertyNamePattern = "{0}_{1}_Reference";
        }
 
        #endregion
 
        #region ICodeWriter Members
 
        public Metadata Metadata { get; set; }
 
        public CodeNamespace TargetNamespace { get; set; }
 
        public void Write()
        {
            WriteImports();
            WriteContextClass();
 
            foreach (var table in Tables)
                WriteTableClass(table);
        }
 
        #endregion
 
        #region Metadata
 
        IEnumerable<Table> Tables
        {
            get { return Metadata.Tables.Values.OrderBy(t => t.ClassName); }
        }
 
        #endregion
 
        #region Write Imports
 
        void WriteImports()
        {
            WriteImport("System");
            WriteImport("System.Collections.Generic");
            WriteImport("System.ComponentModel.DataAnnotations");
            WriteImport("System.ComponentModel.DataAnnotations.Schema");
            WriteImport("System.Data.Entity");
 
            if (DataContract != null)
                WriteImport("System.Runtime.Serialization");
 
            if (NewtonsoftJson != null)
                WriteImport("Newtonsoft.Json");
 
            WriteImport("SspMain");
 
            ConvertImports(TargetNamespace.Imports);
        }
 
        void WriteImport(string ns)
        {
            TargetNamespace.Imports.Add(new CodeNamespaceImport(ns));
        }
 
        #endregion
 
        #region Write Context
 
        void WriteContextClass()
        {
            var contextClass = new CodeTypeDeclaration(ContextClassName) { IsPartial = true };
 
            foreach (var table in Tables)
                WriteContextTableProperty(contextClass, table);
 
            WriteContextOnModelCreatingMethod(contextClass);
            WriteContextRequiredFieldMessage(contextClass);
 
            TargetNamespace.Types.Add(contextClass);
        }
 
        void WriteContextTableProperty(CodeTypeDeclaration contextClass, Table table)
        {
            var tableClass = new CodeTypeReference(table.ClassName);
 
            var getDbSet = new CodeMethodInvokeExpression(
                new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), TableQueryFactoryMethodName, tableClass)
            );
 
            var property = new CodeMemberProperty
            {
                Attributes = MemberAttributes.Public | MemberAttributes.Final,
                Type = new CodeTypeReference(TableQueryTypeName, tableClass),
                Name = table.ClassName
            };
 
            property.GetStatements.Add(new CodeMethodReturnStatement(getDbSet));
 
            contextClass.Members.Add(property);
        }
 
        void WriteContextRequiredFieldMessage(CodeTypeDeclaration contextClass)
        {
            var requiredMessage = new CodeMemberField(typeof(string), RequiredMessageConstName)
            {
                Attributes = MemberAttributes.Const | MemberAttributes.Assembly,
                InitExpression = new CodePrimitiveExpression(RequiredMessage)
            };
 
            contextClass.Members.Add(requiredMessage);
 
            var maxTextLengthMessage = new CodeMemberField(typeof(string), MaxTextLengthMessageConstName)
            {
                Attributes = MemberAttributes.Const | MemberAttributes.Assembly,
                InitExpression = new CodePrimitiveExpression(MaxTextLengthMessage)
            };
 
            contextClass.Members.Add(maxTextLengthMessage);
        }
 
        void WriteContextOnModelCreatingMethod(CodeTypeDeclaration contextClass)
        {
            var method = new CodeMemberMethod
            {
                Name = "OnModelCreating",
                Attributes = MemberAttributes.Override | MemberAttributes.Family
            };
 
            method.Parameters.Add(new CodeParameterDeclarationExpression("DbModelBuilder", "modelBuilder"));
 
            method.Statements.Add(new CodeMethodInvokeExpression(
                new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "OnModelCreating"),
                new CodeVariableReferenceExpression("modelBuilder")
            ));
 
            WriteDecimalColumnsMapping(method);
 
            if (IsOnModelCreatingInternalInvoke)
                method.Statements.Add(new CodeMethodInvokeExpression(
                    new CodeMethodReferenceExpression { MethodName = "OnModelCreatingInternal" },
                    new CodeVariableReferenceExpression("modelBuilder")
                ));
 
            contextClass.Members.Add(method);
        }
 
        void WriteDecimalColumnsMapping(CodeMemberMethod method)
        {
            var decimalColumns =
                from t in Tables
                from c in t.Columns.Values
                where (Nullable.GetUnderlyingType(c.Db.ClrType) ?? c.Db.ClrType) == typeof(decimal)
                orderby t.Db.Name.NameWithSchema, c.Db.OrdinalPosition
                select new { Table = t, Column = c };
 
            foreach (var item in decimalColumns)
            {
                var modelBuilder = new CodeVariableReferenceExpression("modelBuilder");
 
                var entity = new CodeMethodInvokeExpression(
                    new CodeMethodReferenceExpression(
                        modelBuilder,
                        "Entity",
                        new CodeTypeReference(item.Table.ClassName)
                    )
                );
 
                var property = new CodeMethodInvokeExpression(
                    entity,
                    "Property",
                    new CodeSnippetExpression(
                        string.Format(GetPropertyNameExpressionPattern, item.Column.PropertyName)
                    )
                );
 
                var hasPrecision = new CodeMethodInvokeExpression(
                    property,
                    "HasPrecision",
                    new CodePrimitiveExpression(item.Column.Db.Precision),
                    new CodePrimitiveExpression(item.Column.Db.Scale)
                );
 
                method.Statements.Add(hasPrecision);
            }
        }
 
        #endregion
 
        #region Write Table
 
        void WriteTableClass(Table table)
        {
            var tableClass = new CodeTypeDeclaration(table.ClassName) { IsPartial = true };
 
            tableClass.CustomAttributes.Add(new CodeAttributeDeclaration(
                "Table",
                new CodeAttributeArgument(new CodePrimitiveExpression(table.Db.Name.Name)),
                new CodeAttributeArgument("Schema", new CodePrimitiveExpression(table.Db.Name.Schema))
            ));
 
            if (DataContract != null)
            {
                if (DataContract.Namespace == "")
                    tableClass.CustomAttributes.Add(new CodeAttributeDeclaration("DataContract"));
                else
                    tableClass.CustomAttributes.Add(new CodeAttributeDeclaration(
                        "DataContract",
                        new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(DataContract.Namespace))
                    ));
            }
 
            foreach (var column in table.Columns.Values.OrderBy(v => v.Db.OrdinalPosition))
                WriteTableColumnProperty(tableClass, table, column);
 
            foreach (var reference in table.References.OrderBy(r => r.RefTable.Db.Name.NameWithSchema))
                WriteTableReferenceProperty(tableClass, reference);
 
            foreach (var reference in table.BackReferences.OrderBy(r => r.Table.Db.Name.NameWithSchema))
                WriteTableBackReferenceProperty(tableClass, reference);
 
            WriteTablePropertyChangedImpl(tableClass);
 
            TargetNamespace.Types.Add(tableClass);
        }
 
        void WriteTablePropertyChangedImpl(CodeTypeDeclaration tableClass)
        {
            if (PropertyChanged == null)
                return;
 
            tableClass.BaseTypes.Add(new CodeTypeReference(typeof(INotifyPropertyChanged)));
 
            var propertyChanged = new CodeMemberEvent
            {
                Name = "PropertyChanged",
                Type = new CodeTypeReference(typeof(PropertyChangedEventHandler)),
                Attributes = MemberAttributes.Public
            };
 
            var onPropertyChanged = new CodeMemberMethod
            {
                Name = PropertyChanged.MethodName,
                Attributes = MemberAttributes.Family | MemberAttributes.Overloaded
            };
 
            var onPropertyChangedPropertyName =
                new CodeParameterDeclarationExpression(typeof(string), "propertyName");
 
            onPropertyChanged.Parameters.Add(onPropertyChangedPropertyName);
 
            var onPropertyChangedH = new CodeVariableDeclarationStatement(
                propertyChanged.Type,
                "h",
                new CodeFieldReferenceExpression(null, propertyChanged.Name)
            );
 
            onPropertyChanged.Statements.Add(onPropertyChangedH);
 
            onPropertyChanged.Statements.Add(new CodeConditionStatement(
                new CodeBinaryOperatorExpression(
                    new CodeVariableReferenceExpression(onPropertyChangedH.Name),
                    CodeBinaryOperatorType.IdentityInequality,
                    new CodePrimitiveExpression(null)
                ),
                new CodeExpressionStatement(new CodeMethodInvokeExpression(
                    new CodeMethodReferenceExpression(null, onPropertyChangedH.Name),
                    new CodeThisReferenceExpression(),
                    new CodeObjectCreateExpression(
                        typeof(PropertyChangedEventArgs),
                        new CodeVariableReferenceExpression(onPropertyChangedPropertyName.Name)
                    )
                ))
            ));
 
            tableClass.Members.Add(onPropertyChanged);
            tableClass.Members.Add(propertyChanged);
        }
 
        void WriteTableColumnProperty(CodeTypeDeclaration tableClass, Table table, Column column)
        {
            var property = WriteProperty(
                tableClass,
                new CodeTypeReference(column.Db.ClrType),
                column.PropertyName
            );
 
            var columnAttribute = new CodeAttributeDeclaration(
                "Column",
                new CodeAttributeArgument(new CodePrimitiveExpression(column.Db.Name))
            );
 
            if (column.Db.PkIndex.HasValue)
            {
                property.CustomAttributes.Add(new CodeAttributeDeclaration("Key"));
 
                columnAttribute.Arguments.Add(
                    new CodeAttributeArgument("Order", new CodePrimitiveExpression(column.Db.PkIndex.Value))
                );
 
                var reference = table.References
                    .FirstOrDefault(r => r.Columns.Contains(column) && r.Type == ReferenceTypes.OneToOne);
 
                if (reference != null)
                    property.CustomAttributes.Add(new CodeAttributeDeclaration(
                        "ForeignKey",
                        new CodeAttributeArgument(
                            new CodePrimitiveExpression(GetTableReferencePropertyName(reference))
                        )
                    ));
            }
 
            property.CustomAttributes.Add(columnAttribute);
 
            if (column.Db.PkIndex.HasValue || column.Db.DbGenerationMode != DbGenerationModes.None)
                property.CustomAttributes.Add(new CodeAttributeDeclaration(
                    "DatabaseGenerated",
                    new CodeAttributeArgument(new CodeFieldReferenceExpression(
                        new CodeTypeReferenceExpression("DatabaseGeneratedOption"),
                        column.Db.DbGenerationMode.ToString()
                    ))
                ));
 
            if (column.Db.IsRowVersion)
                property.CustomAttributes.Add(new CodeAttributeDeclaration("ConcurrencyCheck"));
 
            var isRequired =
                column.Db.IsNullable == false &&
                column.Db.DbGenerationMode == DbGenerationModes.None &&
                column.Db.PkIndex.HasValue == false;
 
            if (isRequired)
                property.CustomAttributes.Add(new CodeAttributeDeclaration(
                    "Required",
                    new CodeAttributeArgument(
                        "ErrorMessage",
                        new CodeFieldReferenceExpression(
                            new CodeTypeReferenceExpression(ContextClassName),
                            RequiredMessageConstName
                        )
                    )
                ));
 
            if (column.Db.ClrType == typeof(string) && column.Db.MaxTextLength.HasValue)
                property.CustomAttributes.Add(new CodeAttributeDeclaration(
                    "MaxLength",
                    new CodeAttributeArgument(new CodePrimitiveExpression(column.Db.MaxTextLength)),
                    new CodeAttributeArgument(
                        "ErrorMessage",
                        new CodeFieldReferenceExpression(
                            new CodeTypeReferenceExpression(ContextClassName),
                            MaxTextLengthMessageConstName
                        )
                    )
                ));
 
            if (DataContract != null)
            {
                if (isRequired && DataContract.IsDataMemberRequired)
                    property.CustomAttributes.Add(new CodeAttributeDeclaration(
                        "DataMember",
                        new CodeAttributeArgument("IsRequired", new CodePrimitiveExpression(true))
                    ));
                else
                    property.CustomAttributes.Add(new CodeAttributeDeclaration("DataMember"));
            }
        }
 
        void WriteTableReferenceProperty(CodeTypeDeclaration tableClass, Reference reference)
        {
            var property = WriteProperty(
                tableClass,
                new CodeTypeReference(reference.RefTable.ClassName),
                GetTableReferencePropertyName(reference)
            );
 
            property.CustomAttributes.Add(new CodeAttributeDeclaration(
                "ForeignKey",
                new CodeAttributeArgument(
                    new CodePrimitiveExpression(string.Join(",", reference.Columns.Select(c => c.PropertyName)))
                )
            ));
 
            WriteTableReferenceSerializationInfo(property);
        }
 
        void WriteTableBackReferenceProperty(CodeTypeDeclaration tableClass, Reference reference)
        {
            var type = reference.Type == ReferenceTypes.OneToOne
                ? new CodeTypeReference(reference.Table.ClassName)
                : new CodeTypeReference(CollectionType, new CodeTypeReference(reference.Table.ClassName));
 
            var property = WriteProperty(tableClass, type, GetTableBackReferencePropertyName(reference));
 
            property.CustomAttributes.Add(new CodeAttributeDeclaration(
                "InverseProperty",
                new CodeAttributeArgument(
                    new CodePrimitiveExpression(GetTableReferencePropertyName(reference))
 
                )
            ));
 
            WriteTableReferenceSerializationInfo(property);
        }
 
        void WriteTableReferenceSerializationInfo(CodeMemberProperty property)
        {
            if (NewtonsoftJson != null && NewtonsoftJson.IsReferencesInDataContract == false)
                property.CustomAttributes.Add(new CodeAttributeDeclaration("JsonIgnore"));
 
            if (DataContract != null && DataContract.IsReferencesInDataContract)
                property.CustomAttributes.Add(new CodeAttributeDeclaration("DataMember"));
        }
 
        string GetTableReferencePropertyName(Reference reference)
        {
            return string.Format(
                ReferencePropertyNamePattern,
                string.Join("_", reference.Columns.Select(c => c.PropertyName))
            );
        }
 
        string GetTableBackReferencePropertyName(Reference reference)
        {
            return string.Format(
                BackReferencePropertyNamePattern,
                reference.Table.ClassName,
                string.Join("_", reference.Columns.Select(c => c.PropertyName))
            );
        }
 
        #endregion
 
        #region Utils
 
        CodeMemberProperty WriteProperty(CodeTypeDeclaration parentClass, CodeTypeReference propertyType, string propertyName)
        {
            var field = new CodeMemberField(
                propertyType,
                propertyName + "__Field"
            );
 
            parentClass.Members.Add(field);
 
            var result = new CodeMemberProperty
            {
                Type = propertyType,
                Name = propertyName,
                Attributes = MemberAttributes.Public | MemberAttributes.Final
            };
 
            result.GetStatements.Add(new CodeMethodReturnStatement(
                new CodeFieldReferenceExpression { FieldName = field.Name }
            ));
 
            result.SetStatements.Add(new CodeAssignStatement(
                new CodeFieldReferenceExpression { FieldName = field.Name },
                new CodePropertySetValueReferenceExpression()
            ));
 
            if (PropertyChanged != null)
                result.SetStatements.Add(new CodeMethodInvokeExpression(
                    new CodeMethodReferenceExpression { MethodName = PropertyChanged.MethodName },
                    new CodePrimitiveExpression(propertyName)
                ));
 
            parentClass.Members.Add(result);
 
            return result;
        }
 
        #endregion
    }
}