using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using AbstraX.ServerInterfaces;

using AbstraX;

using System.ComponentModel.DataAnnotations;

using System.ServiceModel.DomainServices.Server;

using Reflection = System.Reflection;

using E = System.Linq.Expressions;

using System.Linq.Expressions;

using System.Runtime.Serialization;

using MvvmTreeView;

using AbstraX.XPathBuilder;

using System.Diagnostics;

using AbstraX.Templates;

using AbstraX.AssemblyInterfaces;

using AbstraX.TypeMappings;

using AbstraX.Contracts;



namespace AssemblyProvider.Web.Entities

{

    [DataContract, NodeImage("AssemblyProvider.Web.Images.Assembly.png"), DebuggerDisplay("{ DebugInfo }"), ClientCodeGeneration(typeof(AbstraXClientInterfaceGenerator))]

    public class Assembly : IElement, IAssembly

    {

        private string assemblyFile;

        private AssembliesRoot parent;

        private Reflection.Assembly assembly;

        private string queryWhereProperty;

        private object queryWhereValue;



        public Assembly()

        { 

        }

        public Assembly(Reflection.Assembly assembly, string file, AssembliesRoot parent)

        {

            this.assembly = assembly;

            this.assemblyFile = file;

            this.parent = parent;

        }



        public Assembly(Reflection.Assembly assembly, AssembliesRoot parent)

        {

            this.assembly = assembly;

            this.parent = parent;

        }



        [DataMember]

        public float ChildOrdinal

        {

            get

            {

                return 0;

            }

        }



        [DataMember]

        public string DebugInfo

        {

            get

            {

                return this.Name + ID;

            }

        }



        [DataMember, Key]

        public string ID

        {

            get 

            {

                if (assemblyFile != null)

                {

                    return this.MakeID("AssemblyFile='" + this.assemblyFile + "'");

                }

                else

                {

                    return this.MakeID("Assembly='" + this.assembly.FullName + "'");

                }

            }

        }



        [DataMember]

        public string FolderKeyPair { get; set; }



        [DataMember]

        public string ParentID

        {

            get

            {

                return parent.ID;

            }

        }



        [DataMember]

        public IEnumerable<IAttribute> Attributes

        {

            get { throw new NotImplementedException(); }

        }



        [Association("Assembly_Types", "ID", "ParentID")]

        public List<AssemblyType> Types

        {

            get

            {

                var types = new List<AssemblyType>();



                try

                {

                    if (queryWhereProperty != null && queryWhereProperty == "Type")

                    {

                        var type = assembly.GetType((string)queryWhereValue);



                        Debug.Assert(type != null);



                        types.Add(new AssemblyType(type, this));

                    }

                    else

                    {

                        foreach (System.Type type in assembly.GetTypes().Where(t => t.IsPublic))

                        {

                            types.Add(new AssemblyType(type, this));

                        }

                    }

                }

                catch

                {

                }



                return types;

            }

        }



        [DataMember]

        public IEnumerable<IElement> ChildElements

        {

            get 

            {

                var elements = this.Types.AsQueryable().Cast<IElement>().Select(e => e);



                return elements;

            }

        }



        [DataMember]

        public IEnumerable<IOperation> Operations

        {

            get 

            {

                return null;

            }

        }



        [Include, Association("Parent_BaseType", "ID", "ParentID"), ClientCodeGeneration(typeof(AbstraXClientInterfaceGenerator))]

        public BaseType DataType

        {

            get 

            {

                return null;

            }

        }



        [DataMember]

        public string Description

        {

            get 

            {

                return string.Empty;

            }

        }



        [DataMember]

        public string Documentation

        {

            get 

            {

                return string.Empty;

            }

        }



        [DataMember]

        public string ImageURL

        {

            get 

            {

                return string.Empty;

            }

        }



        [DataMember]

        public string Name

        {

            get

            {

                return assembly.FullName;

            }

        }



        public IBase Parent

        {

            get 

            {

                return parent;

            }

        }



        [DataMember]

        public bool IsContainer

        {

            get 

            {

                return true;

            }

        }



        public void ExecuteWhere(string property, object value)

        {

            if (value is XPathAxisElement && (property == "ID" || property == "ParentID"))

            {

                var predicate = ((XPathAxisElement)value).Predicates.First();



                queryWhereProperty = predicate.Left;

                queryWhereValue = predicate.Right;

            }

            else

            {

                Debugger.Break();



                queryWhereProperty = property;

                queryWhereValue = value;

            }

        }



        public void ExecuteWhere(Expression expression)

        {

            throw new NotImplementedException();

        }



        public void ExecuteWhere(XPathAxisElement element)

        {

            var predicate = element.Predicates.First();



            queryWhereProperty = predicate.Left;

            queryWhereValue = predicate.Right;

        }



        public void ClearPredicates()

        {

            queryWhereProperty = null;

            queryWhereValue = null;

        }



        public IRoot Root

        {

            get

            {

                IBase baseObject = this;



                while (baseObject != null)

                {

                    baseObject = baseObject.Parent;



                    if (baseObject is IRoot)

                    {

                        return (IRoot)baseObject;

                    }

                }



                return null;

            }

        }





        [DataMember]

        public DefinitionKind Kind

        {

            get

            {

                return DefinitionKind.NotApplicable;

            }

        }



        [DataMember]

        public bool HasChildren

        {

            get 

            {

                return assembly.GetTypes().Any();

            }

        }



        IEnumerable<IAssemblyType> IAssembly.Types

        {

            get

            {

                foreach (var type in this.Types)

                {

                    yield return type;

                }

            }

        }



        [DataMember, Include, Association("Parent_Facet", "ID", "ParentID")]

        public Facet[] Facets

        {

            get

            {

                return null;

            }

        }



        [Exclude]

        public ContainerType AllowableContainerTypes

        {

            get { throw new NotImplementedException(); }

        }



        [Exclude]

        public ConstructType AllowableConstructTypes

        {

            get { throw new NotImplementedException(); }

        }



        [Exclude]

        public ContainerType DefaultContainerType

        {

            get { throw new NotImplementedException(); }

        }



        [Exclude]

        public ConstructType DefaultConstructType

        {

            get { throw new NotImplementedException(); }

        }

    }

}