using System;

namespace Chernobyl
{
    /// <summary>
    /// Thrown when an instance of an improper type is provided to some code.
    /// </summary>
    public class InvalidTypeException : Exception
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidTypeException" />
        /// class whose <see cref="Exception.InnerException" /> is set to null.
        /// </summary>
        /// <param name="message">The error message that explains the reason for
        /// the exception.</param>
        /// <param name="instance">The instance that was of improper type.</param>
        /// <param name="expectedType">The type that <paramref name="instance"/>
        /// was expected to be.</param>
        public InvalidTypeException(string message, object instance, Type expectedType)
            : this(message, instance, expectedType, null)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="InvalidTypeException"/> 
        /// class.
        /// </summary>
        /// <param name="message">The error message that explains the reason for 
        /// the exception.</param>
        /// <param name="instance">The instance that was of improper type.</param>
        /// <param name="expectedType">The type that <paramref name="instance"/>
        /// was expected to be.</param>
        /// <param name="innerException">The exception that is the cause of the 
        /// current exception, or a null reference (Nothing in Visual Basic) if 
        /// no inner exception is specified.</param>
        public InvalidTypeException(string message, object instance, Type expectedType, Exception innerException)
            : base(message, innerException)
        {
            Instance = instance;
        }

        /// <summary>
        /// The instance that was of improper type.
        /// </summary>
        public object Instance { get; private set; }

        /// <summary>
        /// The type that <see cref="Instance"/> was expected to be.
        /// </summary>
        public Type ExpectedType { get; private set; }
    }

    /// <summary>
    /// Extension and utility methods for <see cref="InvalidTypeException"/> and
    /// related types.
    /// </summary>
    public static class MethodExceptionExtensions
    {
        /// <summary>
        /// Casts the provided <paramref name="instance" /> to <typeparamref name="T" />
        /// and returns it. If it cannot be casted, an <see cref="InvalidTypeException" />
        /// is thrown.
        /// </summary>
        /// <typeparam name="T">The type to cast <paramref name="instance"/> to.</typeparam>
        /// <param name="instance">The instance that is to be casted.</param>
        /// <returns>The casted <paramref name="instance"/>.</returns>
        /// <exception cref="InvalidTypeException">Thrown when the provided
        /// <paramref name="instance" /> cannot be casted to <typeparamref name="T" />.</exception>
        public static T Require<T>(this object instance) where T : class
        {
            T castedInstance = instance as T;
            if (castedInstance == null)
                throw new InvalidTypeException(
                    string.Format("'{0}' must be of type '{1}'.",
                                  instance, typeof(T)), instance, typeof(T));
            return castedInstance;
        }
    }
}