/*  
  Copyright 2009 David Schmitt <david@dasz.at> (http://dasz.at/)

 This program is licensed under the GNU Lesser General Public License (LGPL).  You should 
 have received a copy of the license along with the source code.  If not, an online copy
 of the license can be found at http://www.gnu.org/copyleft/lesser.html.
*/

using System;
using NGenerics.Util;

namespace NGenerics.DataStructures.General
{
    /// <summary>
    /// An immutable class representing a pair of values with value semantics.
    /// </summary>
    /// <typeparam name="T">The type of object the pair contains.</typeparam>
#if (!SILVERLIGHT)
    [Serializable]
#endif
    public class Pair<T>
    {
        #region Globals

        private readonly T a;
        private readonly T b;

        #endregion

        #region Construction

        /// <param name="a">The first value.</param>
        /// <param name="b">The other value.</param>
        public Pair(T a, T b)
        {
            this.a = a;
            this.b = b;
        }

        #endregion

        #region Public Members

        /// <summary>
        /// Gets the A-half of this <see cref="Pair{T}"/>.
        /// </summary>
        /// <value>The A-half.</value>
        public T A
        {
            get
            {
                return this.a;
            }
        }

        /// <summary>
        /// Gets the B-half of this <see cref="Pair{T}"/>.
        /// </summary>
        /// <value>The B-half.</value>
        public T B
        {
            get
            {
                return this.b;
            }
        }

        #endregion

        #region Object Overrides

        /// <summary>
        /// Creates a user-readable string representation of this Pair.
        /// </summary>
        /// <returns>A user-readable string.</returns>
        public override string ToString()
        {
            return String.Format("({0}, {1})", this.a, this.b);
        }

        /// <summary>
        /// Compares this Pair to another Pair, based on their parts.
        /// </summary>
        /// <param name="obj">The object to compare to.</param>
        /// <returns>If the <paramref name="obj"/> is a pair of the same objects as this pair, returns true. Returns false otherwise.</returns>
        public override bool Equals(object obj)
        {
            // shortcut reference equality
            if (Object.ReferenceEquals(this, obj))
            {
                return true;
            }

            var other = obj as Pair<T>;

            if (other == null)
            {
                return false;
            }

            return Object.Equals(this.a, other.a) && Object.Equals(this.b, other.b);
        }

        /// <summary>
        /// Calculates a hash code from this pair's constituents.
        /// </summary>
        /// <returns>A hashcode suitable for use in Hastables and similar structures.</returns>
        public override int GetHashCode()
        {
            return (Object.ReferenceEquals(this.a, null) ? 0 : this.a.GetHashCode())
                ^ (Object.ReferenceEquals(this.b, null) ? 0 : this.b.GetHashCode());
        }

        /// <summary>
        /// Compares the two Pairs based on their constituents.
        /// </summary>
        /// <param name="left">The first element to compare.</param>
        /// <param name="right">The second element to compare.</param>
        /// <returns>true, if both pairs have the same contents; false,otherwise.</returns>
        public static bool operator ==(Pair<T> left, Pair<T> right)
        {
            // shortcut reference equality
            if (Object.ReferenceEquals(left, right))
            {
                return true;
            }

            return Object.ReferenceEquals(left, null) || left.Equals(right);
        }

        /// <summary>
        /// Compares the two Pairs based on their constituents.
        /// </summary>
        /// <param name="left">The first element to compare.</param>
        /// <param name="right">The second element to compare.</param>
        /// <returns>false, if both pairs have the same contents; true,otherwise.</returns>
        public static bool operator !=(Pair<T> left, Pair<T> right)
        {
            return !(left == right);
        }

        #endregion
    }

    /// <summary>
    /// A few utility methods that do not need access to the private state of a <see cref="Pair{T}"/>.
    /// </summary>
    public static class PairExtensions
    {
        /// <summary>
        /// Creates a new <see cref="Pair{T}"/> with A and B switched. 
        /// </summary>
        /// <typeparam name="T">The type contained in the <see cref="Pair{T}"/>.</typeparam>
        /// <param name="self">The pair whose constituents are used. May not be null.</param>
        /// <returns></returns>
        public static Pair<T> Reverse<T>(this Pair<T> self)
        {
            Guard.ArgumentNotNull(self, "self");

            if (Object.Equals(self.A, self.B))
            {
                return self;
            }
            else
            {
                return new Pair<T>(self.B, self.A);
            }
        }

        public static System.Collections.Generic.KeyValuePair<T, T> ToKeyValuePair<T>(this Pair<T> self)
        {
            return new System.Collections.Generic.KeyValuePair<T, T>(self.A, self.B);
        }
    }
}