using System;
using System.ComponentModel;
using System.Linq.Expressions;
using NUnit.Framework;

namespace Tests
{
    /// <summary>
    /// Collection of usefull extension methods to help testing viewmodel properties.
    /// </summary>
    public static class TestViewModelHelper
    {
        /// <summary>
        /// Test that a string property of a viewmodel class has a correct behavior:
        /// - write a value and read it back to check its value
        /// - ensure that the PropertyChanged event is raised properly
        /// </summary>
        /// <typeparam name="T">Type of the ViewModel</typeparam>
        /// <typeparam name="U">Type of the property to test.  Supported types are bool, string, int and bouel</typeparam>
        /// <param name="viewmodel">Instance of a ViewModel object</param>
        /// <param name="expression">Expression which evaluate the property to test</param>
        public static void TestProperty<T, U>(T viewmodel, Expression<Func<T, U>> expression)
            where T : INotifyPropertyChanged
        {
            if(expression.Body is MemberExpression)
            {
                MemberExpression memberExpression = (MemberExpression) expression.Body;

                if (expression.Body.Type == typeof(bool))
                {
                    TestViewModelProperty(viewmodel, memberExpression.Member.Name, true, false);
                }
                else if (expression.Body.Type == typeof(string))
                {
                    TestViewModelProperty(viewmodel, memberExpression.Member.Name, "value1", "value2");
                } 
                else if (expression.Body.Type == typeof(int))
                {
                    TestViewModelProperty(viewmodel, memberExpression.Member.Name, 1, 99);
                }
                else if (expression.Body.Type == typeof(double))
                {
                    TestViewModelProperty(viewmodel, memberExpression.Member.Name, 1.0, 99.0);
                }
                else
                {
                    throw new NotSupportedException("Type is not supported");
                }
            }
        }

        /// <summary>
        /// Test that a property of a viewmodel class has a correct behavior:
        /// - write a value and read it back to check its value
        /// - ensure that the PropertyChanged event is raised properly
        /// </summary>
        /// <typeparam name="T">Type of the viewmodel</typeparam>
        /// <param name="viewModel">ViewModel instance</param>
        /// <param name="propertyName">Name of the property to test</param>
        private static void TestViewModelProperty<T, U>(T viewModel, string propertyName, U value1, U value2)
            where T : INotifyPropertyChanged
        {
            bool propertyChanged;
            viewModel.PropertyChanged += (s, e) => propertyChanged = e.PropertyName == propertyName;

            propertyChanged = false;
            viewModel.SetValue(propertyName, value1);
            Assert.IsTrue(propertyChanged);
            Assert.IsTrue(viewModel.GetValue<U>(propertyName).Equals(value1));

            propertyChanged = false;
            viewModel.SetValue(propertyName, value2);
            Assert.IsTrue(propertyChanged);
            Assert.IsTrue(viewModel.GetValue<U>(propertyName).Equals(value2));
        }

        /// <summary>
        /// Gets a property on a object by reflection
        /// </summary>
        /// <typeparam name="T">Type of the value to get</typeparam>
        /// <param name="obj">Instance of the object which has the property</param>
        /// <param name="propertyName">Name of the property to get</param>
        /// <returns>Value of the property on this object</returns>
        private static T GetValue<T>(this object obj, string propertyName)
        {
            var propertyInfo = obj.GetType().GetProperty(propertyName);
            return (T)propertyInfo.GetValue(obj, null);
        }

        /// <summary>
        /// Sets a property on a object by reflection
        /// </summary>
        /// <typeparam name="T">Type of the value to set</typeparam>
        /// <param name="obj">Instance of the object which has the property</param>
        /// <param name="propertyName">Name of the property to set</param>
        /// <param name="value">Value to set</param>
        private static void SetValue<T>(this object obj, string propertyName, T value)
        {
            var propertyInfo = obj.GetType().GetProperty(propertyName);
            propertyInfo.SetValue(obj, value, null);
        }
    }
}