////////////////////////////////////////////////////////////////////////////////////////
// File: AxeHosting.h
//
// Abstract: This file contains definitions that are consumed by AXE Hosting applications.
//
// (c) Microsoft. All rights reserved.
////////////////////////////////////////////////////////////////////////////////////////


#if defined( _MSC_VER )
#pragma once
#endif  // _MSC_VER

#if !defined( AXEHOSTING_H )
#define AXEHOSTING_H

#if NTDDI_VERSION >= NTDDI_WIN7

// This file is only for C++ clients. C is not supported.
//
#if !defined( __cplusplus )
#error C++ compiler required
#endif // C++


////////////////////////////////////////////////////////////////////////////////////////
// Include files
////////////////////////////////////////////////////////////////////////////////////////

#include "AxeCore.h"


////////////////////////////////////////////////////////////////////////////////////////
// Forward declarations (global namespace)
////////////////////////////////////////////////////////////////////////////////////////

struct _EVENT_RECORD; // #include <evntcons.h>


// The AXE Solution APIs exist in the Microsoft::Assessments::Hosting namespace.
//
namespace Microsoft { namespace Assessments { namespace Hosting
{
    ////////////////////////////////////////////////////////////////////////////////////////
    // Constants
    ////////////////////////////////////////////////////////////////////////////////////////

    static const size_t RESULTS_MAX_FILENAME = 65;


    ////////////////////////////////////////////////////////////////////////////////////////
    // Forward declarations
    ////////////////////////////////////////////////////////////////////////////////////////

    __interface Solution;
    __interface Engine;
    __interface Job;
    __interface Assessment;


    ////////////////////////////////////////////////////////////////////////////////////////
    // Type defines
    ////////////////////////////////////////////////////////////////////////////////////////


    ////////////////////////////////////////////////////////////////////////////////////////
    // Enumerations
    ////////////////////////////////////////////////////////////////////////////////////////

    enum SolutionFlags
    {
        SolutionFlagNone                            = 0,
        SolutionFlagWorkloads                       = 0x1 << 31,  // 0x80000000
    };

    namespace JobExecutionFlags { enum JobExecutionFlags
    {
        None                                        = 0,
        ExecuteAsync                                = 0x1 << 0,  // 0x00000001
    }; }

    enum SolutionError
    {
        SolutionErrorNone                           = 0,
        SolutionErrorAlreadyInit                    = AXE_E_ALREADY_INIT,
        SolutionErrorWorkloadInit                   = AXE_E_WORKLOAD_INIT,
        SolutionErrorInternalError                  = AXE_E_INTERNAL_ERROR,
        SolutionErrorUnknownWin32Error              = AXE_E_UNKNOWN_WIN32_ERROR,
        SolutionErrorBadManifest                    = AXE_E_BAD_MANIFEST,
        SolutionErrorJobRunning                     = AXE_E_JOB_RUNNING,
        SolutionErrorJobNotRunning                  = AXE_E_JOB_NOT_RUNNING,
        SolutionErrorShellExecuteNoProcess          = AXE_E_SHELLEXECUTE_NOPROCESS,
        SolutionErrorQueuedEvents                   = AXE_E_QUEUED_APC_EVENTS,
    };

    enum AssessmentExecutionError
    {
        AssessmentExecutionErrorNone                 = 0,
        AssessmentExecutionErrorCouldNotStart        = AXE_E_ASSESSMENT_COULD_NOT_START,
        AssessmentExecutionErrorCouldNotFinish       = AXE_E_ASSESSMENT_COULD_NOT_FINISH,
        AssessmentExecutionErrorCompletedWithError   = AXE_E_ASSESSMENT_COMPLETED_WITH_ERROR,
        AssessmentExecutionErrorResultsInvalid       = AXE_E_ASSESSMENT_RESULTS_INVALID,
        AssessmentExecutionErrorCanceled             = AXE_E_ASSESSMENT_CANCELED,
        AssessmentExecutionErrorTerminated           = AXE_E_ASSESSMENT_TERMINATED,
        AssessmentExecutionErrorCrashed              = AXE_E_ASSESSMENT_CRASHED
    };

    enum JobExecutionError
    {
        JobExecutionErrorNone                        = 0,
        JobExecutionErrorCanceled                    = AXE_E_JOB_CANCELED,
        JobExecutionErrorAssessmentsFailed           = AXE_E_JOB_ASSESSMENTS_FAILED,
        JobExecutionErrorAnotherRebootPending        = AXE_E_JOB_ANOTHER_REBOOT_PENDING,
        JobExecutionErrorNoRebootPending             = AXE_E_JOB_NO_REBOOT_PENDING,
        JobExecutionErrorPreparation                 = AXE_E_JOB_PREPARATION,
        JobExecutionErrorResultsFailed               = AXE_E_JOB_RESULTS_FAILED,
        JobExecutionErrorAssessmentPreparation       = AXE_E_JOB_ASSESSMENT_PREPARATION,
        JobExecutionErrorPostExecution               = AXE_E_JOB_POSTEXECUTION,
        JobExecutionErrorWaitTimeout                 = AXE_E_JOB_WAIT_TIMEOUT,
        JobExecutionErrorChanged                     = AXE_E_JOB_CHANGED,
        JobExecutionErrorRestartFailed               = AXE_E_JOB_RESTART_FAILED,
        JobExecutionErrorRestartBadData              = AXE_E_JOB_RESTART_BADDATA,
        JobExecutionErrorSolutionRestart             = AXE_E_JOB_SOLUTION_RESTART        
    };

    enum ThreadingModel
    {
        ThreadingModelNone = 0,  // always first
        ThreadingModelFree,
        ThreadingModelAPC,
        ThreadingModelInvalid  // always last
    };


    ////////////////////////////////////////////////////////////////////////////////////////
    // Structures
    ////////////////////////////////////////////////////////////////////////////////////////

    struct SolutionParameters
    {
        DWORD Size;
        DWORD Flags;
    };

    struct JobExecutionInfo
    {
        DWORD Size;
        const Job* Job;
        DWORD Flags;
        DWORD Timeout;
        LPCWSTR RestartDirectory;
        LPCWSTR RestartCommand;
        LPCWSTR RestartMinimumCommand;
        LPCWSTR WorkloadTempDirectory;
        INT WorkloadAssessmentIndex;
        JobExecutionError Error;
        BOOL Restarting;
    };

    // OnJobPending event argument structure
    //
    struct JobPendingEventArgs
    {
        DWORD Size;
        const Job* Job;
        DWORD Timeout;
    };

    // OnJobBegin event argument structure
    //
    struct JobBeginEventArgs
    {
        DWORD Size;
        const Job* Job;
    };

    // OnJobRestart event argument structure
    //
    struct JobRestartEventArgs
    {
        DWORD Size;
        const Job* Job;
    };

    // OnJobEnd event argument structure
    //
    struct JobEndEventArgs
    {
        DWORD Size;
        const Job* Job;
        JobExecutionError Error;
        const ErrorList* ErrorList;
        UINT ExecutedAssessmentCount;
        UINT FailedAssessmentCount;
        LPCWSTR ResultPath;
        WCHAR ResultFolder[RESULTS_MAX_FILENAME];
        WCHAR ResultFileName[RESULTS_MAX_FILENAME];
    };

    // OnAssessmentBegin event argument structure
    //
    struct AssessmentBeginEventArgs
    {
        DWORD Size;
        INT AssessmentIndex;
        const Assessment* Assessment;
    };

    // OnAssessmentEnd event argument structure
    //
    struct AssessmentEndEventArgs
    {
        DWORD Size;
        INT AssessmentIndex;
        const Assessment* Assessment;
        AssessmentExecutionError Error;
        const ErrorList* ErrorList;
        INT ExitCode;
    };

    // OnProgressUpdate event argument structure
    //
    struct ProgressUpdateEventArgs
    {
        DWORD Size;
        INT AssessmentIndex;
        const Assessment* Assessment;
        AxeProgressType ProgressType;
        UINT ProgressValue;
        LPCWSTR ProgressMessage;
    };

    // ILogReaderCallback LogReaderCallback data structure.
    //
    struct LogReaderCallbackData
    {
        struct _EVENT_RECORD* EventRecord;
        FILETIME Timestamp;
        LPCWSTR LogDate;
        LPCWSTR LogTime;
        LPCWSTR LogText;
        LPCWSTR LogError;
    };


    ////////////////////////////////////////////////////////////////////////////////////////
    // Event Interfaces/Delegates
    ////////////////////////////////////////////////////////////////////////////////////////

    // JobPending event handler
    //
    __interface IJobPendingEventHandler
    {
        void OnJobPending(
            Engine* sender,
            const JobPendingEventArgs* e);
    };

    // JobBegin event handler
    //
    __interface IJobBeginEventHandler
    {
        void OnJobBegin(
            Engine* sender,
            const JobBeginEventArgs* e);
    };

    // JobRestart event handler
    //
    __interface IJobRestartEventHandler
    {
        void OnJobRestart(
            Engine* sender,
            const JobRestartEventArgs* e);
    };

    // JobEnd event handler
    //
    __interface IJobEndEventHandler
    {
        void OnJobEnd(
            Engine* sender,
            const JobEndEventArgs* e);
    };

    // AssessmentBegin handler
    //
    __interface IAssessmentBeginEventHandler
    {
        void OnAssessmentBegin(
            Engine* sender,
            const AssessmentBeginEventArgs* e);
    };

    // AssessmentEnd event handler
    //
    __interface IAssessmentEndEventHandler
    {
        void OnAssessmentEnd(
            Engine* sender,
            const AssessmentEndEventArgs* e);
    };

    // ProgressUpdate event handler
    //
    __interface IProgressUpdateEventHandler
    {
        void OnProgressUpdate(
            Engine* sender,
            const ProgressUpdateEventArgs* e);
    };

    // Solution ReadLogFile callback.
    //
    __interface ILogReaderCallback
    {
        BOOL LogReaderCallback(
            const LogReaderCallbackData* data);
    };


    ////////////////////////////////////////////////////////////////////////////////////////
    // Interfaces
    ////////////////////////////////////////////////////////////////////////////////////////

    // Solution interface
    //
    __interface Solution : public IUnknown
    {
        HRESULT GetErrorText(
            _In_ HRESULT axeError,
            _Deref_out_ ErrorList** errorList);
        HRESULT CreateEngine(
            _Deref_out_ Engine** engine);
        HRESULT CreateJob(
            _In_z_ LPCWSTR jobPath,
            _Deref_out_ Job** newJob);
        HRESULT CreateJob(
            _In_z_ LPCWSTR jobPath,
            _Deref_out_ Job** newJob,
            _Deref_opt_out_opt_ ErrorList** errorList);
        HRESULT CreateLogger(
            _Deref_out_ Logging** log);
        HRESULT ReadLogFile(
            _In_z_ LPCWSTR logPath,
            _In_ ILogReaderCallback* callback);
        HRESULT GetSessionFolder(
            _Outptr_opt_result_maybenull_z_ LPCWSTR* sessionFolder) const;
        HRESULT GetSessionLogFile(
            _Outptr_opt_result_maybenull_z_ LPCWSTR* sessionLogFile) const;
    };

    // Engine interface
    //
    __interface Engine : public IUnknown
    {
        HRESULT GetEventThreadingModel(
            _Out_ ThreadingModel* eventThreadingModel);
        HRESULT SetEventThreadingModel(
            _In_ ThreadingModel eventThreadingModel);
        HRESULT SetJobPending(
            _In_opt_ IJobPendingEventHandler* jobPending);
        HRESULT SetJobBegin(
            _In_opt_ IJobBeginEventHandler* jobBegin);
        HRESULT SetJobRestart(
            _In_opt_ IJobRestartEventHandler* jobRestart);
        HRESULT SetJobEnd(
            _In_opt_ IJobEndEventHandler* jobEnd);
        HRESULT SetAssessmentBegin(
            _In_opt_ IAssessmentBeginEventHandler* assessmentBegin);
        HRESULT SetAssessmentEnd(
            _In_opt_ IAssessmentEndEventHandler* assessmentEnd);
        HRESULT SetProgressUpdate(
            _In_opt_ IProgressUpdateEventHandler* progressUpdate);
        HRESULT ExecuteJob(
            _Inout_ JobExecutionInfo* jobInfo);
        HRESULT CancelAssessment(
            INT assessmentIndex);
        HRESULT CancelJob();
        HRESULT TerminateJob();
        HRESULT RemovePendingRebootJob();
    };

    // Job interface
    //
    __interface Job : public IUnknown
    {
        HRESULT GetName(
            _Outptr_opt_result_maybenull_z_ LPCWSTR* jobName) const;
        HRESULT GetToolTip(
            _Outptr_opt_result_maybenull_z_ LPCWSTR* toolTip) const;
        HRESULT GetAssessmentCount(
            _Out_ INT* count) const;
        HRESULT GetAssessment(
            _In_ INT assessmentIndex,
            _COM_Outptr_opt_result_maybenull_ const Assessment** assessment) const;
        HRESULT GetJobParameter(
            _In_z_ LPCWSTR parameterName,
            _Outptr_opt_result_maybenull_z_ LPCWSTR* parameterValue) const;
        HRESULT SetJobParameter(
            _In_z_ LPCWSTR parameterName,
            _In_z_ LPCWSTR parameterValue);
        HRESULT CheckPrerequisites(
            _COM_Outptr_ PrerequisiteCollection** issues);
    };

    // Assessment interface
    //
    __interface Assessment
    {
        HRESULT GetName(
            _Outptr_opt_result_maybenull_z_ LPCWSTR* assessmentName) const;
        HRESULT GetProgrammaticName(
            _Outptr_opt_result_maybenull_z_ LPCWSTR* assessmentProgrammaticName) const;
        HRESULT GetToolTip(
            _Outptr_opt_result_maybenull_z_ LPCWSTR* toolTip) const;
        HRESULT GetWorkloadAssessmentCount(
            _Out_ INT* count) const;
        HRESULT GetWorkloadAssessment(
            _In_ INT assessmentIndex,
            _COM_Outptr_opt_result_maybenull_ const Assessment** assessment) const;
    };

} } }  // end namespace Microsoft::Assessments::Hosting


////////////////////////////////////////////////////////////////////////////////////////
// Factory function
////////////////////////////////////////////////////////////////////////////////////////

extern "C"
{
    HRESULT WINAPI AxeInitSolution(
        _Inout_opt_ Microsoft::Assessments::Hosting::SolutionParameters* pParams,
        _Outptr_opt_result_maybenull_ Microsoft::Assessments::Hosting::Solution** ppSolution);
    typedef HRESULT ( WINAPI * PFNAXE_INITSOLUTION)(
        _Inout_opt_ LPVOID pReserved,
        _Outptr_opt_result_maybenull_ Microsoft::Assessments::Hosting::Solution** ppSolution);
    #define AXE_INITSOLUTION "AxeInitSolution"
}

#endif  // NTDDI_VERSION >= NTDDI_WIN7

#endif  // AXEHOSTING_H
