// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System.ComponentModel;
using Microsoft.Xml.Serialization;
using System.Diagnostics;
 
namespace Microsoft.Xml.Schema
{
    using System;
    using Microsoft.Xml;
 
 
 
    /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement"]/*' />
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    public class XmlSchemaElement : XmlSchemaParticle
    {
        private bool _isAbstract;
        private bool _hasAbstractAttribute;
        private bool _isNillable;
        private bool _hasNillableAttribute;
        private bool _isLocalTypeDerivationChecked;
 
        private XmlSchemaDerivationMethod _block = XmlSchemaDerivationMethod.None;
        private XmlSchemaDerivationMethod _final = XmlSchemaDerivationMethod.None;
        private XmlSchemaForm _form = XmlSchemaForm.None;
        private string _defaultValue;
        private string _fixedValue;
        private string _name;
 
        private XmlQualifiedName _refName = XmlQualifiedName.Empty;
        private XmlQualifiedName _substitutionGroup = XmlQualifiedName.Empty;
        private XmlQualifiedName _typeName = XmlQualifiedName.Empty;
        private XmlSchemaType _type = null;
 
        private XmlQualifiedName _qualifiedName = XmlQualifiedName.Empty;
        private XmlSchemaType _elementType;
        private XmlSchemaDerivationMethod _blockResolved;
        private XmlSchemaDerivationMethod _finalResolved;
        private XmlSchemaObjectCollection _constraints;
        private SchemaElementDecl _elementDecl;
 
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.IsAbstract"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("abstract"), DefaultValue(false)]
        public bool IsAbstract
        {
            get { return _isAbstract; }
            set
            {
                _isAbstract = value;
                _hasAbstractAttribute = true;
            }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Block"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("block"), DefaultValue(XmlSchemaDerivationMethod.None)]
        public XmlSchemaDerivationMethod Block
        {
            get { return _block; }
            set { _block = value; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.DefaultValue"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("default")]
        [DefaultValue(null)]
        public string DefaultValue
        {
            get { return _defaultValue; }
            set { _defaultValue = value; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Final"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("final"), DefaultValue(XmlSchemaDerivationMethod.None)]
        public XmlSchemaDerivationMethod Final
        {
            get { return _final; }
            set { _final = value; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.FixedValue"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("fixed")]
        [DefaultValue(null)]
        public string FixedValue
        {
            get { return _fixedValue; }
            set { _fixedValue = value; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Form"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("form"), DefaultValue(XmlSchemaForm.None)]
        public XmlSchemaForm Form
        {
            get { return _form; }
            set { _form = value; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Name"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("name"), DefaultValue("")]
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.IsNillable"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("nillable"), DefaultValue(false)]
        public bool IsNillable
        {
            get { return _isNillable; }
            set { _isNillable = value; _hasNillableAttribute = true; }
        }
 
        [XmlIgnore]
        internal bool HasNillableAttribute
        {
            get { return _hasNillableAttribute; }
        }
 
        [XmlIgnore]
        internal bool HasAbstractAttribute
        {
            get { return _hasAbstractAttribute; }
        }
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.RefName"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("ref")]
        public XmlQualifiedName RefName
        {
            get { return _refName; }
            set { _refName = (value == null ? XmlQualifiedName.Empty : value); }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.SubstitutionGroup"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("substitutionGroup")]
        public XmlQualifiedName SubstitutionGroup
        {
            get { return _substitutionGroup; }
            set { _substitutionGroup = (value == null ? XmlQualifiedName.Empty : value); }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.SchemaTypeName"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("type")]
        public XmlQualifiedName SchemaTypeName
        {
            get { return _typeName; }
            set { _typeName = (value == null ? XmlQualifiedName.Empty : value); }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.SchemaType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlElement("complexType", typeof(XmlSchemaComplexType)),
         XmlElement("simpleType", typeof(XmlSchemaSimpleType))]
        public XmlSchemaType SchemaType
        {
            get { return _type; }
            set { _type = value; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Constraints"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlElement("key", typeof(XmlSchemaKey)),
         XmlElement("keyref", typeof(XmlSchemaKeyref)),
         XmlElement("unique", typeof(XmlSchemaUnique))]
        public XmlSchemaObjectCollection Constraints
        {
            get
            {
                if (_constraints == null)
                {
                    _constraints = new XmlSchemaObjectCollection();
                }
                return _constraints;
            }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.QualifiedName"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlQualifiedName QualifiedName
        {
            get { return _qualifiedName; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.ElementType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        [Obsolete("This property has been deprecated. Please use ElementSchemaType property that returns a strongly typed element type. http://go.microsoft.com/fwlink/?linkid=14202")]
        public object ElementType
        {
            get
            {
                if (_elementType == null)
                    return null;
 
                if (_elementType.QualifiedName.Namespace == XmlReservedNs.NsXs)
                {
                    return _elementType.Datatype; //returns XmlSchemaDatatype;
                }
                return _elementType;
            }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.ElementType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaType ElementSchemaType
        {
            get { return _elementType; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.BlockResolved"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaDerivationMethod BlockResolved
        {
            get { return _blockResolved; }
        }
 
        /// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.FinalResolved"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaDerivationMethod FinalResolved
        {
            get { return _finalResolved; }
        }
 
        internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet, ValidationEventHandler valEventHandler)
        {
            if (schemaSet != null)
            {
                XmlReaderSettings readerSettings = new XmlReaderSettings();
                readerSettings.ValidationType = ValidationType.Schema;
                readerSettings.Schemas = schemaSet;
                readerSettings.ValidationEventHandler += valEventHandler;
                return new XsdValidatingReader(reader, resolver, readerSettings, this);
            }
            return null;
        }
 
        internal void SetQualifiedName(XmlQualifiedName value)
        {
            _qualifiedName = value;
        }
 
        internal void SetElementType(XmlSchemaType value)
        {
            _elementType = value;
        }
 
        internal void SetBlockResolved(XmlSchemaDerivationMethod value)
        {
            _blockResolved = value;
        }
 
        internal void SetFinalResolved(XmlSchemaDerivationMethod value)
        {
            _finalResolved = value;
        }
 
        [XmlIgnore]
        internal bool HasDefault
        {
            get { return _defaultValue != null && _defaultValue.Length > 0; }
        }
 
        internal bool HasConstraints
        {
            get { return _constraints != null && _constraints.Count > 0; }
        }
 
        internal bool IsLocalTypeDerivationChecked
        {
            get
            {
                return _isLocalTypeDerivationChecked;
            }
            set
            {
                _isLocalTypeDerivationChecked = value;
            }
        }
 
        internal SchemaElementDecl ElementDecl
        {
            get { return _elementDecl; }
            set { _elementDecl = value; }
        }
 
        [XmlIgnore]
        internal override string NameAttribute
        {
            get { return Name; }
            set { Name = value; }
        }
 
        [XmlIgnore]
        internal override string NameString
        {
            get
            {
                return _qualifiedName.ToString();
            }
        }
 
        internal override XmlSchemaObject Clone()
        {
            System.Diagnostics.Debug.Assert(false, "Should never call Clone() on XmlSchemaElement. Call Clone(XmlSchema) instead.");
            return Clone(null);
        }
 
        internal XmlSchemaObject Clone(XmlSchema parentSchema)
        {
            XmlSchemaElement newElem = (XmlSchemaElement)MemberwiseClone();
 
            //Deep clone the QNames as these will be updated on chameleon includes
            newElem._refName = _refName.Clone();
            newElem._substitutionGroup = _substitutionGroup.Clone();
            newElem._typeName = _typeName.Clone();
            newElem._qualifiedName = _qualifiedName.Clone();
            // If this element has a complex type which is anonymous (declared in place with the element)
            //  it needs to be cloned as well, since it may contain named elements and such. And these names
            //  will need to be cloned since they may change their namespace on chameleon includes
            XmlSchemaComplexType complexType = _type as XmlSchemaComplexType;
            if (complexType != null && complexType.QualifiedName.IsEmpty)
            {
                newElem._type = (XmlSchemaType)complexType.Clone(parentSchema);
            }
 
            //Clear compiled tables
            newElem._constraints = null;
            return newElem;
        }
    }
}