// 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.Collections;
using System.ComponentModel;
using Microsoft.Xml.Serialization;
 
namespace Microsoft.Xml.Schema
{
    using System;
    using Microsoft.Xml;
 
 
 
    /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType"]/*' />
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    public class XmlSchemaType : XmlSchemaAnnotated
    {
        private string _name;
        private XmlSchemaDerivationMethod _final = XmlSchemaDerivationMethod.None;
        private XmlSchemaDerivationMethod _derivedBy;
        private XmlSchemaType _baseSchemaType;
        private XmlSchemaDatatype _datatype;
        private XmlSchemaDerivationMethod _finalResolved;
        private volatile SchemaElementDecl _elementDecl;
        private volatile XmlQualifiedName _qname = XmlQualifiedName.Empty;
        private XmlSchemaType _redefined;
 
        //compiled information
        private XmlSchemaContentType _contentType;
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdSimpleType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlQualifiedName qualifiedName)
        {
            if (qualifiedName == null)
            {
                throw new ArgumentNullException("qualifiedName");
            }
            return DatatypeImplementation.GetSimpleTypeFromXsdType(qualifiedName);
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdSimpleType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlTypeCode typeCode)
        {
            return DatatypeImplementation.GetSimpleTypeFromTypeCode(typeCode);
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdComplexType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public static XmlSchemaComplexType GetBuiltInComplexType(XmlTypeCode typeCode)
        {
            if (typeCode == XmlTypeCode.Item)
            {
                return XmlSchemaComplexType.AnyType;
            }
            return null;
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdComplexType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public static XmlSchemaComplexType GetBuiltInComplexType(XmlQualifiedName qualifiedName)
        {
            if (qualifiedName == null)
            {
                throw new ArgumentNullException("qualifiedName");
            }
            if (qualifiedName.Equals(XmlSchemaComplexType.AnyType.QualifiedName))
            {
                return XmlSchemaComplexType.AnyType;
            }
            if (qualifiedName.Equals(XmlSchemaComplexType.UntypedAnyType.QualifiedName))
            {
                return XmlSchemaComplexType.UntypedAnyType;
            }
            return null;
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.Name"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("name")]
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.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\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.QualifiedName"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlQualifiedName QualifiedName
        {
            get { return _qname; }
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.FinalResolved"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaDerivationMethod FinalResolved
        {
            get { return _finalResolved; }
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.BaseSchemaType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        [Obsolete("This property has been deprecated. Please use BaseXmlSchemaType property that returns a strongly typed base schema type. http://go.microsoft.com/fwlink/?linkid=14202")]
        public object BaseSchemaType
        {
            get
            {
                if (_baseSchemaType == null)
                    return null;
 
                if (_baseSchemaType.QualifiedName.Namespace == XmlReservedNs.NsXs)
                {
                    return _baseSchemaType.Datatype;
                }
                return _baseSchemaType;
            }
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.BaseSchemaType"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaType BaseXmlSchemaType
        {
            get { return _baseSchemaType; }
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.DerivedBy"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaDerivationMethod DerivedBy
        {
            get { return _derivedBy; }
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.Datatype"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaDatatype Datatype
        {
            get { return _datatype; }
        }
 
        /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.IsMixed"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public virtual bool IsMixed
        {
            get { return false; }
            set {; }
        }
 
        [XmlIgnore]
        public XmlTypeCode TypeCode
        {
            get
            {
                if (this == XmlSchemaComplexType.AnyType)
                {
                    return XmlTypeCode.Item;
                }
                if (_datatype == null)
                {
                    return XmlTypeCode.None;
                }
                return _datatype.TypeCode;
            }
        }
 
        [XmlIgnore]
        internal XmlValueConverter ValueConverter
        {
            get
            {
                if (_datatype == null)
                { //Default converter
                    return XmlUntypedConverter.Untyped;
                }
                return _datatype.ValueConverter;
            }
        }
 
        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 XmlSchemaContentType SchemaContentType
        {
            get
            {
                return _contentType;
            }
        }
 
        internal void SetQualifiedName(XmlQualifiedName value)
        {
            _qname = value;
        }
 
        internal void SetFinalResolved(XmlSchemaDerivationMethod value)
        {
            _finalResolved = value;
        }
 
        internal void SetBaseSchemaType(XmlSchemaType value)
        {
            _baseSchemaType = value;
        }
 
        internal void SetDerivedBy(XmlSchemaDerivationMethod value)
        {
            _derivedBy = value;
        }
 
        internal void SetDatatype(XmlSchemaDatatype value)
        {
            _datatype = value;
        }
 
        internal SchemaElementDecl ElementDecl
        {
            get { return _elementDecl; }
            set { _elementDecl = value; }
        }
 
        [XmlIgnore]
        internal XmlSchemaType Redefined
        {
            get { return _redefined; }
            set { _redefined = value; }
        }
 
        internal virtual XmlQualifiedName DerivedFrom
        {
            get { return XmlQualifiedName.Empty; }
        }
 
        internal void SetContentType(XmlSchemaContentType value)
        {
            _contentType = value;
        }
 
        public static bool IsDerivedFrom(XmlSchemaType derivedType, XmlSchemaType baseType, XmlSchemaDerivationMethod except)
        {
            if (derivedType == null || baseType == null)
            {
                return false;
            }
 
            if (derivedType == baseType)
            {
                return true;
            }
 
            if (baseType == XmlSchemaComplexType.AnyType)
            { //Not checking for restriction blocked since all types are implicitly derived by restriction from xs:anyType
                return true;
            }
            do
            {
                XmlSchemaSimpleType dt = derivedType as XmlSchemaSimpleType;
                XmlSchemaSimpleType bt = baseType as XmlSchemaSimpleType;
                if (bt != null && dt != null)
                { //SimpleTypes
                    if (bt == DatatypeImplementation.AnySimpleType)
                    { //Not checking block=restriction
                        return true;
                    }
                    if ((except & derivedType.DerivedBy) != 0 || !dt.Datatype.IsDerivedFrom(bt.Datatype))
                    {
                        return false;
                    }
                    return true;
                }
                else
                { //Complex types
                    if ((except & derivedType.DerivedBy) != 0)
                    {
                        return false;
                    }
                    derivedType = derivedType.BaseXmlSchemaType;
                    if (derivedType == baseType)
                    {
                        return true;
                    }
                }
            } while (derivedType != null);
 
            return false;
        }
 
 
        internal static bool IsDerivedFromDatatype(XmlSchemaDatatype derivedDataType, XmlSchemaDatatype baseDataType, XmlSchemaDerivationMethod except)
        {
            if (DatatypeImplementation.AnySimpleType.Datatype == baseDataType)
            {
                return true;
            }
            return derivedDataType.IsDerivedFrom(baseDataType);
        }
 
        [XmlIgnore]
        internal override string NameAttribute
        {
            get { return Name; }
            set { Name = value; }
        }
    }
}