// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using MSBuild = Microsoft.Build.Utilities;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using System;
using System.Reflection;
using System.Linq;
 
namespace Microsoft.Arcade.Common
{
    public abstract partial class MSBuildTaskBase : MSBuild.Task
    {
        #region Common Variables
        protected const string AssetsVirtualDir = "assets/";
        #endregion
 
        /// <summary>
        /// This is the name of the method on the implementation of this class that behaves as "Execute" would in a basic
        /// impelmentation of an MSBuild Task. 
        /// </summary>
        private const string ExecuteMethodName = "ExecuteTask";
 
        /// <summary>
        /// An MSBuild Task uses the Execute method as main method as an entry point into the task's functionality. 
        /// It is extended in this abstract class, behind the scenes, to configure dependency injection. 
        /// </summary>
        /// <returns></returns>
        public override sealed bool Execute()
        {
            ServiceCollection collection = new ServiceCollection();
            ConfigureServices(collection);
            using (var provider = collection.BuildServiceProvider())
            {
                return InvokeExecute(provider);
            }            
        }
 
        /// <summary>
        /// A helper method that takes the service provider contains and extrapolates the dependencies referenced in the
        /// ExecuteTask method and then subsequently invokes the ExecuteTask method. 
        /// 
        /// This method can also be called from tests so that the service provider can contain any mocks that will be used
        /// in the test. 
        /// </summary>
        /// <param name="provider"></param>
        /// <returns></returns>
        public bool InvokeExecute(ServiceProvider provider)
        {
            return (bool)GetExecuteMethod().Invoke(this, GetExecuteArguments(provider));
        }
 
        /// <summary>
        /// Default service configuration. This method can be overridden in the impelmented class so that 
        /// it can configure the dependencies that the implemented task requires. 
        /// 
        /// This method can also be called from the tests to complete the service collection with any dependencies 
        /// that aren't configured for the tests. 
        /// </summary>
        /// <param name="collection"></param>
        public abstract void ConfigureServices(IServiceCollection collection);
 
        /// <summary>
        /// Uses some reflection magic to look up the types of depenencies that to be injected into the implemented task. 
        /// </summary>
        /// <returns></returns>
        public Type[] GetExecuteParameterTypes()
        {
            return GetType().GetMethod(ExecuteMethodName).GetParameters().Select(p => p.ParameterType).ToArray();
        }
 
        /// <summary>
        /// Looks up all the dependencies from the service provider that are defined as parameters in ExecuteTask
        /// so they can be injected into the ExecuteTask method when it's called. 
        /// </summary>
        /// <param name="serviceProvider"></param>
        /// <returns></returns>
        private object[] GetExecuteArguments(ServiceProvider serviceProvider)
        {
            return GetExecuteParameterTypes().Select(t => serviceProvider.GetRequiredService(t)).ToArray();
        }
 
        /// <summary>
        /// Gets the ExecuteTask method that is in the implementation of the MSBuild Task. 
        /// </summary>
        /// <returns></returns>
        private MethodInfo GetExecuteMethod()
        {
            return GetType().GetMethod(ExecuteMethodName);
        }
    }
}