namespace Sitecore.Support.Pipelines.Loader
{
  using System.Text;
  using System.Threading;
  using System.Web.Hosting;
  using System.Xml;
  using Sitecore.Abstractions;
  using Sitecore.Diagnostics;
  using Sitecore.Pipelines;
  using Sitecore.Reflection;
  using Sitecore.Xml;

  /// <summary>
  ///  Configures thread limits for <see cref="ThreadPool"/>.
  /// <para>Thread pool limits should be configured in machine config, however an access to machine config is not provided in cloud, thereby API-based approach must be taken.</para>  
  /// </summary>
  [UsedImplicitly]
  public class ConfigureThreadPool : IInitializable
  {
    #region fields

    /// <summary>
    /// The log to output running thread pool configuration in 'audit' level.
    /// </summary>
    [NotNull]
    private readonly BaseLog Log;

    /// <summary>
    /// Gets or sets the maximum worker threads.
    /// </summary>
    /// <value>
    /// The maximum worker threads.
    /// </value>
    protected int MaxWorkerThreadsPerCore;

    /// <summary>
    /// Gets or sets the maximum completion port threads.
    /// </summary>
    /// <value>
    /// The maximum completion port threads.
    /// </value>
    protected int MaxCompletionPortThreadsPerCore;

    /// <summary>
    /// Gets or sets the minimum worker threads.
    /// </summary>
    /// <value>
    /// The minimum worker threads.
    /// </value>
    protected int MinWorkerThreadsPerCore;

    /// <summary>
    /// Gets or sets the minimum completion port threads.
    /// </summary>
    /// <value>
    /// The minimum completion port threads.
    /// </value>
    protected int MinCompletionPortThreadsPerCore;
    #endregion

    /// <summary>
    /// Initializes a new instance of the <see cref="ConfigureThreadPool"/> class.
    /// </summary>
    /// <param name="log">The log to output running thread pool configuration in 'audit' level.</param>
    public ConfigureThreadPool([NotNull]BaseLog log)
    {
      Assert.ArgumentNotNull(log, nameof(log));
      
      this.Log = log;
    }

    #region Properties

    /// <summary>
    /// Gets a value indicating whether the <see cref="IInitializable" /> needs calling code to assign properties even after <see cref="Initialize"/> calls.
    /// </summary>
    /// <value>
    /// <c>true</c> if the <see cref="IInitializable" /> assigns the  properties; otherwise, <c>false</c>.
    /// </value>
    public virtual bool AssignProperties => false;

    /// <summary>
    /// Gets the processor count.
    /// </summary>
    /// <value>
    /// The processor count.
    /// </value>
    public virtual int ProcessorCount => System.Environment.ProcessorCount;

    /// <summary>
    /// Gets or sets the maximum concurrent requests per CPU.
    /// </summary>
    /// <value>
    /// The maximum concurrent requests allowed to be processed by one CPU at a time.
    /// </value>
    public int MaxConcurrentRequestsPerCPU { get; protected set; }

    /// <summary>
    /// Gets the maximum worker threads.
    /// </summary>
    /// <value>
    /// The maximum worker threads.
    /// </value>
    public int MaxWorkerThreads => this.MaxWorkerThreadsPerCore * this.ProcessorCount;

    /// <summary>
    /// Gets the maximum completion port threads.
    /// </summary>
    /// <value>
    /// The maximum completion port threads.
    /// </value>
    public int MaxCompletionPortThreads => this.MaxCompletionPortThreadsPerCore * this.ProcessorCount;

    /// <summary>
    /// Gets the minimum worker threads.
    /// </summary>
    /// <value>
    /// The minimum worker threads.
    /// </value>
    public int MinWorkerThreads => this.MinWorkerThreadsPerCore * this.ProcessorCount;

    /// <summary>
    /// Gets the minimum completion port threads.
    /// </summary>
    /// <value>
    /// The minimum completion port threads.
    /// </value>
    public int MinCompletionPortThreads => this.MinCompletionPortThreadsPerCore * this.ProcessorCount;

    /// <summary>
    /// Gets a value indicating whether this code is executed in hosted environment (IIS).    
    /// </summary>
    /// <value>
    /// <c>true</c> if this instance is executed in hosting environment (f.e. IIS); otherwise, <c>false</c> (f.e. in tests).
    /// </value>
    protected virtual bool IsHostedEnvironment => HostingEnvironment.IsHosted;

    #endregion

    /// <summary>
    /// Configures thread limits for <see cref="ThreadPool"/> based on configuration values.
    /// </summary>
    /// <param name="args">The arguments.</param>
    public virtual void Process(PipelineArgs args)
    {
      if (!this.IsHostedEnvironment)
      {
        this.Log.Debug("Running outside IIS scope, skipping processor execution");
        return;
      }

      this.LogThreadPoolStatistics(args, "Default thread pool size:");

      if (this.MaxWorkerThreads != 0 && this.MaxCompletionPortThreads != 0)
      {
        this.SetMaxThreadPoolLimit(this.MaxWorkerThreads, this.MaxCompletionPortThreads, args);
      }

      if (this.MinWorkerThreads != 0 && this.MinCompletionPortThreads != 0)
      {
        this.SetMinThreadPoolLimit(this.MinWorkerThreads, this.MinCompletionPortThreads, args);
      }

      if (this.MaxConcurrentRequestsPerCPU != 0)
      {
        HostingEnvironment.MaxConcurrentRequestsPerCPU = this.MaxConcurrentRequestsPerCPU;
      }

      this.LogThreadPoolStatistics(args, "New thread pool size:");
    }

    /// <summary>
    /// Logs the <see cref="ThreadPool"/> statistics.
    /// </summary>
    /// <param name="args">The arguments.</param>
    /// <param name="header">The header for a message to begin with.</param>
    public virtual void LogThreadPoolStatistics(PipelineArgs args, [NotNull] string header)
    {      
      Assert.ArgumentNotNull(header, "header");

      int minWorkerThreads;
      int minCompletionPortThreads;
      int maxWorkerThreads;
      int maxCompletionPortThreads;

      this.GetThreadStatistics(out minWorkerThreads, out minCompletionPortThreads, out maxWorkerThreads, out maxCompletionPortThreads);

      var message = new StringBuilder()
        .AppendLine(header)
        .AppendLine("Processor count:" + this.ProcessorCount)
        .AppendLine("minWorkerThreadsPerCore count:" + minWorkerThreads)
        .AppendLine("minCompletionPortThreadsPerCore count:" + minCompletionPortThreads)
        .AppendLine("maxWorkerThreadsPerCore count:" + maxWorkerThreads)
        .AppendLine("maxCompletionPortThreadsPerCore count:" + maxCompletionPortThreads)
        .AppendLine("MaxConcurrentRequestsPerCPU count:" + this.MaxConcurrentRequestsPerCPU)
        .ToString();

      this.Log.Audit(message, this);
    }

    /// <summary>
    /// Gets the the <see cref="ThreadPool"/> statistics.
    /// </summary>    
    /// <param name="minWorkerThreads">The minimum worker threads.</param>
    /// <param name="minCompletionPortThreads">The minimum completion port threads.</param>
    /// <param name="maxWorkerThreads">The maximum worker threads.</param>
    /// <param name="maxCompletionPortThreads">The maximum completion port threads.</param>
    public virtual void GetThreadStatistics(out int minWorkerThreads, out int minCompletionPortThreads, out int maxWorkerThreads, out int maxCompletionPortThreads)
    {
      ThreadPool.GetMaxThreads(out maxWorkerThreads, out maxCompletionPortThreads);

      ThreadPool.GetMinThreads(out minWorkerThreads, out minCompletionPortThreads);
    }

    /// <summary>
    /// Sets the minimum thread pool limit.
    /// </summary>
    /// <param name="minWorkerThreads">The minimum worker threads.</param>
    /// <param name="minCompletionPortThreads">The minimum completion port threads.</param>
    /// <param name="args">The arguments.</param>
    public virtual void SetMinThreadPoolLimit(int minWorkerThreads, int minCompletionPortThreads, PipelineArgs args)
    {
      ThreadPool.SetMinThreads(minWorkerThreads, minCompletionPortThreads);
    }

    /// <summary>
    /// Sets the maximum thread pool limit.
    /// </summary>
    /// <param name="maxWorkerThreads">The maximum worker threads.</param>
    /// <param name="maxCompletionPortThreads">The maximum completion port threads.</param>
    /// <param name="args">The arguments.</param>
    public virtual void SetMaxThreadPoolLimit(int maxWorkerThreads, int maxCompletionPortThreads, PipelineArgs args)
    {
      ThreadPool.SetMaxThreads(maxWorkerThreads, maxCompletionPortThreads);
    }

    /// <summary>
    /// Initializes the object from the specified config node.
    /// </summary>
    /// <param name="configNode">The config node.</param>
    public virtual void Initialize([CanBeNull]XmlNode configNode)
    {
      if (configNode == null)
      {
        return;
      }

      var attribute = XmlUtil.FindChildNode("MaxWorkerThreadsPerCore", configNode, false);
      if (attribute != null)
      {
        int.TryParse(attribute.InnerText, out this.MaxWorkerThreadsPerCore);
      }

      attribute = XmlUtil.FindChildNode("MaxCompletionPortThreadsPerCore", configNode, false);
      if (attribute != null)
      {
        int.TryParse(attribute.InnerText, out this.MaxCompletionPortThreadsPerCore);
      }

      attribute = XmlUtil.FindChildNode("MinWorkerThreadsPerCore", configNode, false);
      if (attribute != null)
      {
        int.TryParse(attribute.InnerText, out this.MinWorkerThreadsPerCore);
      }

      attribute = XmlUtil.FindChildNode("MinCompletionPortThreadsPerCore", configNode, false);
      if (attribute != null)
      {
        int.TryParse(attribute.InnerText, out this.MinCompletionPortThreadsPerCore);
      }
      
      attribute = XmlUtil.FindChildNode("MaxConcurrentRequestsPerCPU", configNode, false);
      if (attribute != null)
      {
        int maxConcurrentRequestsPerCPU;
        int.TryParse(attribute.InnerText, out maxConcurrentRequestsPerCPU);
        this.MaxConcurrentRequestsPerCPU = maxConcurrentRequestsPerCPU;
      }
    }
  }
}