using System;
using System.Collections.Generic;
using System.Text;
using DaveSexton.DocProject;
using DaveSexton.DocProject.Engine;

namespace SandcastleDocumentation
{
    /// <summary>
    /// Hooks into the DocProject build process for the project in which it's defined.
    /// </summary>
    /// <remarks>
    /// <para>
    /// This class must be registered with the DocSite in the <em>Active Projects</em>
    /// tools options page in order for DocProject to instantiate it during a help build.
    /// </para>
    /// <para>
    /// The add-in will create an instance of this class in its own AppDomain instead 
    /// of Visual Studio's default AppDomain.  Therefore, it's important to use the 
    /// <see cref="BuildContext.Invoke" /> method overloads to marshal calls back to the 
    /// UI thread when using Visual Studio automation.  The automation methods inherited from 
    /// <see cref="BuildProcessComponent" />, such as 
    /// <see cref="BuildProcessComponent.TraceLine" /> and 
    /// <see cref="BuildProcessComponent.ShowDialog" />, marshal calls to Visual Studio's 
    /// AppDomain automatically.
    /// </para>
    /// <para>
    /// To cancel the build at any time call the <see cref="BuildContext.Cancel" /> 
    /// method.  The build process will end after the current step is executed, 
    /// unless the step is being executed in the background.  In that case, it may 
    /// end immediately.
    /// </para>
    /// <para>
    /// Note: Do not cache instances of the <see cref="BuildContext" /> class and do 
    /// not invoke its members asynchronously.  <see cref="BuildContext" /> is not 
    /// thread-safe and is recreated each time the project is built.
    /// </para>
    /// </remarks>
    public class BuildProcess : BuildProcessComponent
    {
        DateTime buildStart, stepStart;

        /// <summary>
        /// Called by the add-in before the project's help build actually starts.
        /// </summary>
        /// <param name="context">Provides information about the build process.</param>
        public override void BuildStarting(BuildContext context)
        {
            // Uncomment the following line to break into the debugger: 
            //System.Diagnostics.Debugger.Break();

            buildStart = DateTime.Now;
        }

        /// <summary>
        /// Called by the add-in immediately before a <paramref name="step" /> is executed 
        /// during a help build.
        /// </summary>
        /// <param name="step"><see cref="IBuildStep" /> implementation to be executed.</param>
        /// <param name="context">Provides information about the build process.</param>
        /// <returns><b>true</b> indicates that the process should continue; otherwise, 
        /// <b>false</b> indicates that the process should skip this step.</returns>
        public override bool BeforeExecuteStep(IBuildStep step, BuildContext context)
        {
            stepStart = DateTime.Now;

            if (step.Name.Equals("Compile Help 1.x"))
                ProcessHelpCustomTopics(context, "Html");
            else if (step.Name.Equals("Compile Help 2.x"))
                ProcessHelp2CustomTopics(context, "Html2");
            
            return true;
        }

        private void ProcessHelp2CustomTopics(BuildContext context, string target)
        {
            TraceLine();
            TraceLine("Importing custom topics...");
            TraceLine("Target: {0}", target);
            int topicsMerged = CustomTopics.ImportHelp2(context, target);

            TraceLine("{0} topic(s) imported.", topicsMerged);
        }

        private void ProcessHelpCustomTopics(BuildContext context, string target)
        {
            TraceLine();
            TraceLine("Importing custom topics...");
            TraceLine("Target: {0}", target);
            int topicsMerged = CustomTopics.Import(context, target);

            TraceLine("{0} topic(s) imported.", topicsMerged);
        }

        /// <summary>
        /// Called by the add-in immediately after a <paramref name="step" /> has been 
        /// executed during a help build.
        /// </summary>
        /// <param name="step"><see cref="IBuildStep" /> implementation to be executed.</param>
        /// <param name="context">Provides information about the build process.</param>
        public override void AfterExecuteStep(IBuildStep step, BuildContext context)
        {
            TraceLine();
            TraceLine("Step {0} Time Elapsed: {1}", context.CurrentStepIndex + 1, DateTime.Now - stepStart);
        }

        /// <summary>
        /// Called by the add-in after the project's help build has finished.
        /// </summary>
        /// <remarks>
        /// The <see cref="BuildContext.Cancel" /> method has no affect at this 
        /// point in the build process.  This method is the final step before the 
        /// add-in displays the build statistics.
        /// <para>
        /// This method is always invoked if <see cref="BuildStarting" /> is invoked, 
        /// regardless of whether an exception is thrown in any of the other methods, 
        /// <see cref="BuildContext.Cancel" /> has been called, or an exeception has
        /// been thrown by the build engine.
        /// </para>
        /// <para>
        /// To determine whether a help build failed or succeeded, examine the value of the
        /// <see cref="BuildContext.BuildState" /> property.
        /// </para>
        /// </remarks>
        /// <param name="context">Provides information about the build process.</param>
        public override void BuildCompleted(BuildContext context)
        {
            TraceLine();
            TraceLine("Total Time Elapsed: {0}", DateTime.Now - buildStart);
        }
    }
}