// ==--==
//   Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// ==--==
// <OWNER>Microsoft</OWNER>
// 
 
using System;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Runtime.Serialization;
 
namespace System.Security.Policy
{
    /// <summary>
    ///     Descriptor stored in the Evidence collection to detail the information we have about a type of
    ///     evidence. This descriptor also stores any evidence that's been generated of the specific type.
    /// </summary>
    [Serializable]
    internal sealed class EvidenceTypeDescriptor
    {
        [NonSerialized]
        private bool m_hostCanGenerate;
 
        [NonSerialized]
        private bool m_generated;
 
        private EvidenceBase m_hostEvidence;
        private EvidenceBase m_assemblyEvidence;
 
        // EvidenceTypeDescriptors are stored in Evidence indexed by the type they describe, so this
        // information is redundant.  We keep it around in checked builds to help debugging, but we can drop
        // it from retial builds.
#if _DEBUG
        [NonSerialized]
        private Type m_evidenceType;
#endif // _DEBUG
 
        public EvidenceTypeDescriptor()
        {
        }
 
        /// <summary>
        ///     Make a deep copy of a type descriptor
        /// </summary>
        private EvidenceTypeDescriptor(EvidenceTypeDescriptor descriptor)
        {
            Contract.Assert(descriptor != null);
 
            m_hostCanGenerate = descriptor.m_hostCanGenerate;
 
            if (descriptor.m_assemblyEvidence != null)
            {
                m_assemblyEvidence = descriptor.m_assemblyEvidence.Clone() as EvidenceBase;
            }
            if (descriptor.m_hostEvidence != null)
            {
                m_hostEvidence = descriptor.m_hostEvidence.Clone() as EvidenceBase;
            }
 
#if _DEBUG
            m_evidenceType = descriptor.m_evidenceType;
#endif // _DEBUG
        }
 
        /// <summary>
        ///     Evidence of this type supplied by the assembly
        /// </summary>
        public EvidenceBase AssemblyEvidence
        {
            get { return m_assemblyEvidence; }
 
            set
            {
                Contract.Assert(value != null);
#if _DEBUG
                Contract.Assert(CheckEvidenceType(value), "Incorrect type of AssemblyEvidence set");
#endif
                m_assemblyEvidence = value;
            }
        }
 
        /// <summary>
        ///     Flag indicating that we've already attempted to generate this type of evidence
        /// </summary>
        public bool Generated
        {
            get { return m_generated; }
 
            set
            {
                Contract.Assert(value, "Attempt to clear the Generated flag");
                m_generated = value;
            }
        }
 
        /// <summary>
        ///     Has the HostSecurityManager has told us that it can potentially generate evidence of this type
        /// </summary>
        public bool HostCanGenerate
        {
            get { return m_hostCanGenerate; }
 
            set
            {
                Contract.Assert(value, "Attempt to clear HostCanGenerate flag");
                m_hostCanGenerate = value;
            }
        }
 
        /// <summary>
        ///     Evidence of this type supplied by the CLR or the host
        /// </summary>
        public EvidenceBase HostEvidence
        {
            get { return m_hostEvidence; }
 
            set
            {
                Contract.Assert(value != null);
#if _DEBUG
                Contract.Assert(CheckEvidenceType(value), "Incorrect type of HostEvidence set");
#endif
                m_hostEvidence = value;
            }
        }
 
#if _DEBUG
        /// <summary>
        ///     Verify that evidence being stored in this descriptor is of the correct type
        /// </summary>
        private bool CheckEvidenceType(EvidenceBase evidence)
        {
            Contract.Assert(evidence != null);
 
            ILegacyEvidenceAdapter legacyAdapter = evidence as ILegacyEvidenceAdapter;
            Type storedType = legacyAdapter == null ? evidence.GetType() : legacyAdapter.EvidenceType;
 
            return m_evidenceType == null || m_evidenceType.IsAssignableFrom(storedType);
        }
#endif // _DEBUG
 
        /// <summary>
        ///     Make a deep copy of this descriptor
        /// </summary>
        public EvidenceTypeDescriptor Clone()
        {
            return new EvidenceTypeDescriptor(this);
        }
 
#if _DEBUG
        /// <summary>
        ///     Set the type that this evidence descriptor refers to.
        /// </summary>
        internal void SetEvidenceType(Type evidenceType)
        {
            Contract.Assert(evidenceType != null);
            Contract.Assert(m_evidenceType == null, "Attempt to reset evidence type");
 
            m_evidenceType = evidenceType;
        }
#endif // _DEBUG
    }
}