////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   Service/CredentialsManager/Credentials.sg
//
//  Note:	Classes for representing credentials and evidence.
//

using System;
using System.Collections;
using System.Diagnostics;
using Microsoft.Contracts;
using Microsoft.Singularity;
using Microsoft.Singularity.Channels;
using Microsoft.Singularity.Directory;
using Microsoft.Singularity.Io;
using Microsoft.SingSharp;
using Ex = Microsoft.Singularity.Security;

namespace Microsoft.Singularity.Security.CredentialsManager
{
    ///
    //<summary>
    //  <para>
    //      This class contains a set of credentials, including sensitive "private" info,
    //      such as passwords, private keys, etc.  The Credentials Manager allows clients
    //      to create these entries, enumerate them, etc., but never allows the private
    //      info to flow out of the credentials manager.  The CM also allows clients to
    //      create "supplicants", which are instances of security protocols that are
    //      allowed to make use of the private info, but not to expose it.
    //  </para>
    //</summary>
    //
    class Credentials
    {
        public Credentials(CredentialsId! id, CredentialsEvidence! evidence)
        {
            this.Id = id;
            this.Evidence = evidence;
        }
        
        public CredentialsId! Id;
        public CredentialsEvidence! Evidence;
    }

    ///
    //<summary>	
    //  <para>
    //      This class is used as a key in Hashtable, so it implements identity comparison
    //      methods, including Object.GetHashCode(), operator==, operator!=, and Object.Equals().
    //  </para>
    //  <para>
    //      Instances of this class are immutable.
    //  </para>
    //</summary>
    //
    class CredentialsId
    {
        public CredentialsId(string! name, string! tag)
        {
            this.CredentialsName = name;
            this.Tag = tag;
        }
        
        public CredentialsId(Ex.CredentialsId excredentials)
        {
            this(
                Bitter.ToString2(excredentials.CredentialsName),
                Bitter.ToString2(excredentials.Tag));
        }
        
        public readonly string! CredentialsName;
        public readonly string! Tag;
        
        override public string! ToString()
        {
            return String.Format("[CredentialsId: name:{0} tag:{1}]", this.CredentialsName, this.Tag);
        }
        
        public Ex.CredentialsId ToExchange()
        {
            Ex.CredentialsId ex = new Ex.CredentialsId();
            ex.CredentialsName = Bitter.FromString2(this.CredentialsName);
            ex.Tag = Bitter.FromString2(this.Tag);
            return ex;
        }
        
        override public int GetHashCode()
        {
            return unchecked((int)(CredentialsName.GetHashCode() + 3 * Tag.GetHashCode()));
        }
        
        override public bool Equals(object obj)
        {
            CredentialsId comparand = obj as CredentialsId;
            if (comparand == null)
                return false;
            
            return this == comparand;
        }
        
        public static bool operator== (CredentialsId! a, CredentialsId! b)
        {
            return a.CredentialsName == b.CredentialsName && a.Tag == b.Tag;
        }
        
        public static bool operator!= (CredentialsId! a, CredentialsId! b)
        {
            return a.CredentialsName != b.CredentialsName || a.Tag != b.Tag;
        }
    }
    
    
    // Base class for classes that provide evidence of ownership of a key.
    abstract class CredentialsEvidence
    {
    }
    
    class PasswordEvidence : CredentialsEvidence
    {
        public PasswordEvidence(string! password)
        {
            this.Password = password;
        }
        
        public readonly string! Password;
    }
    
    //
    //class PrivateKeyEvidence : CredentialsEvidence
    //{
    //  ???
    //}
    //
}