#include "windows.h"

#include "conio.h"
#include "stdio.h"
#include "stdint.h"

/** Всего проводится NUMBER_OF_MEASURINGS серий измерений, каждая серия содержит
* по NUMBER_OF_LAUNCHES запусков, при каждом запуске окно программы задерживается на экране
* на LATENCY_BEFORE_TERMINATE_IN_MS миллисекунд.
*/
#define NUMBER_OF_APPLICATIONS 2
#define NUMBER_OF_MEASURINGS 2
#define NUMBER_OF_LAUNCHES 2
#define LATENCY_BEFORE_TERMINATE_IN_MS 500

/** Созданное окно перемещается в точку с координатами LEFT_UPPER_CORNER_X : LEFT_UPPER_CORNER_Y
* и его размер меняется на размер LENGTH : WIDTH
*/
#define LEFT_UPPER_CORNER_X 0
#define LEFT_UPPER_CORNER_Y 0
#define LENGTH 100
#define WIDTH 100
#define HIDE 0
#define FULLSCREEN 1

void printErrorAndExit(char* functionName)
{
    printf("Error %i while calling %s", GetLastError(), functionName);
    exit(EXIT_SUCCESS);
}

BOOL CALLBACK enumAndResizeCallbackProc(HWND hwnd, LPARAM processHandle)
{
    DWORD buffForHandles = 0;
    int result = 0;

    result = GetWindowThreadProcessId(hwnd, &buffForHandles);
    if (result == 0)
    {
        printErrorAndExit("GetWindowThreadProcessId");
    }

    if (buffForHandles == processHandle)
    {
        buffForHandles = SetWindowPos(hwnd, HWND_TOP, LEFT_UPPER_CORNER_X, LEFT_UPPER_CORNER_Y, LENGTH, WIDTH, 0);
        if (buffForHandles == 0)
        {
            printErrorAndExit("SetWindowPos");
        }

        if(HIDE)
        {
            ShowWindow(hwnd, SW_MINIMIZE);
        }
        else if(FULLSCREEN)
        {
            ShowWindow(hwnd, SW_MAXIMIZE);
        }
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

int main()
{
    int result;
    /** Эта переменная будет использована позже в финальном цикле для вычисления среднего арифметического времени, затраченного на запуск одного экземпляра приложения. */
    double accum;
    int64_t beginTicksTiming, endTicksTiming, ticksPerSecond;
    /** Массив launchRates содержит данные о каждой серии измерений для каждого приложения. */
    double launchRates[NUMBER_OF_APPLICATIONS][NUMBER_OF_MEASURINGS];
    char* applicationNames[NUMBER_OF_APPLICATIONS] = {
        "D:\\Microsoft Office\\OFFICE11\\EXCEL.exe",
        /*"D:\\Microsoft Office Excel 2003.exe"*/
        /*"notepad.exe",*/
        "notepad.exe"
    };


    /** Структуры типа STARTUPINFO и PROCESS_INFORMATION передаются в качестве параметров в функцию CreateProcess
    * для передачи и получения информации о процессе. В данной работе структуры используются только для получения дескриптора созданного процесса.
    */
    STARTUPINFO startupInfo = { 0 };
    startupInfo.cb = sizeof(STARTUPINFO);

    PROCESS_INFORMATION processInfo = { 0 };

    result = QueryPerformanceFrequency((LARGE_INTEGER*)&ticksPerSecond);
    if (result == 0)
    {
        printErrorAndExit("QueryPerformanceFrequency");
    }

    /** Для каждого приложения проводится серия измерений по несколько созданий-уничтожений процесса. Время выполнения серии записывается в массив. */
    for (int currentApplication = 0; currentApplication < NUMBER_OF_APPLICATIONS; currentApplication++)
    {
        for (int currentMeasuring = 0; currentMeasuring < NUMBER_OF_MEASURINGS; currentMeasuring++)
        {
            launchRates[currentApplication][currentMeasuring] = 0;

            result = QueryPerformanceCounter((LARGE_INTEGER*)&beginTicksTiming);
            if (result == 0)
            {
                printErrorAndExit("QueryPerformanceCounter");
            }

            for (int currentLaunch = 0; currentLaunch < NUMBER_OF_LAUNCHES; currentLaunch++)
            {
                result = CreateProcess(0, applicationNames[currentApplication], 0, 0, 0, 0, 0, 0, &startupInfo, &processInfo);
                if (result == 0)
                {
                    printErrorAndExit("CreateProcess");
                }

                result = WaitForInputIdle(processInfo.hProcess, INFINITE);
                if (result == WAIT_FAILED)
                {
                    printErrorAndExit("WaitForInputIdle");
                }

                result = EnumWindows(enumAndResizeCallbackProc, processInfo.dwProcessId);
                if (result != ERROR)
                {
                    printErrorAndExit("EnumWindows");
                }

                Sleep(LATENCY_BEFORE_TERMINATE_IN_MS);

                result = TerminateProcess(processInfo.hProcess, 0);
                if (result == 0)
                {
                    printErrorAndExit("TerminateProcess");
                }

                result = CloseHandle(processInfo.hThread);
                if (result == 0)
                {
                    printErrorAndExit("CloseHandle");
                }
            }

            result = QueryPerformanceCounter((LARGE_INTEGER*)&endTicksTiming);
            if (result == 0)
            {
                printErrorAndExit("QueryPerformanceCounter");
            }

            /**В конце проведения каждой серии измерений записывается время, затраченное на серию. */
            launchRates[currentApplication][currentMeasuring] = (endTicksTiming - beginTicksTiming) / (double)ticksPerSecond;
        }
    }

    /** В финальном цикле на экран выводится среднее время запуска одного экземпляра приложения для каждого приложения. */
    for (int currentApplication = 0; currentApplication < NUMBER_OF_APPLICATIONS; currentApplication++)
    {
        accum = 0;
        for (int currentMeasuring = 0; currentMeasuring < NUMBER_OF_MEASURINGS; currentMeasuring++)
        {
            accum += launchRates[currentApplication][currentMeasuring];
        }
        accum /= (NUMBER_OF_LAUNCHES * NUMBER_OF_APPLICATIONS);
        accum -= (LATENCY_BEFORE_TERMINATE_IN_MS / 1000.0);
        printf("%s : average time for %i cycles from %i launches (without latency) is %4.2f seconds.\n", applicationNames[currentApplication], NUMBER_OF_MEASURINGS, NUMBER_OF_LAUNCHES, accum);
    }
}