#include "windows.h"

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

#define FILE_SIZE (32 * 1024)

char FileBuff[FILE_SIZE];
const char FileName[] = "in.txt";

struct ThreadParams
{
    HANDLE hMutex;
    const int fileSize;
    const char fileName[64];
    char* fileBuff;
};

char generateRandomSymbol()
{
    return ((char)((rand() % (126 + 1 - 33)) + 33));
}

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

void createFileAndFillRandomChars(const char* const filename, const int filesize)
{
    HANDLE file = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if(INVALID_HANDLE_VALUE == file)
    {
        printErrorAndExit("CreateFile");
    }

    int result = 0;
    int buff = 0;
    for(uint64_t i = 0; i < filesize; i++)
    {
        buff = generateRandomSymbol();
        WriteFile(file, &buff, 1, &result, 0);
        if(0 == result)
        {
            printErrorAndExit("WriteFile");
        }
    }

    result = CloseHandle(file);
    if(0 == result)
    {
        printErrorAndExit("CloseHandle");
    }
}

void mapFileToRam(const char* const filename, const int filesize, char* filebuff)
{
    int result = 0;
    OFSTRUCT buff = {0};

    HANDLE file = OpenFile(filename, &buff, OF_READ);
    if(INVALID_HANDLE_VALUE == file)
    {
        printErrorAndExit("OpenFile");
    }

    ReadFile(file, filebuff, filesize, &result, NULL);
    if(0 == result)
    {
        printErrorAndExit("ReadFile");
    }

    result = CloseHandle(file);
    if(0 == result)
    {
        printErrorAndExit("CloseHandle");
    }
}

DWORD firstThreadFunction(LPVOID par)
{
    int bytesWritten = 0;
    int result = WaitForSingleObject(((struct ThreadParams*)par)->hMutex, INFINITE);
    if(WAIT_OBJECT_0 != result)
    {
        printErrorAndExit("WaitForSingleObject");
    }

    HANDLE file = CreateFile(((struct ThreadParams*)par)->fileName, GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
    if(INVALID_HANDLE_VALUE == file)
    {
        printErrorAndExit("CreateFile");
    }

    int a[10] = {0};
    WriteFile(file, ((struct ThreadParams*)par)->fileBuff, ((struct ThreadParams*)par)->fileSize, &bytesWritten, a);
    if(0 == bytesWritten)
    {
        printErrorAndExit("WriteFile");
    }

    result = CloseHandle(file);
    if(0 == result)
    {
        printErrorAndExit("CloseHandle");
    }

    result = ReleaseMutex(((struct ThreadParams*)par)->hMutex);
    if(0 == result)
    {
        printErrorAndExit("ReleaseMutex");
    }
}

DWORD secondThreadFunction(LPVOID par)
{
    int result = WaitForSingleObject(((struct ThreadParams*)par)->hMutex, INFINITE);
    if(WAIT_OBJECT_0 != result)
    {
        printErrorAndExit("WaitForSingleObject");
    }

    for(uint64_t i = 0; i < ((struct ThreadParams*)par)->fileSize; i+= 2)
    {
        ((struct ThreadParams*)par)->fileBuff[i] = '*';
    }

    result = ReleaseMutex(((struct ThreadParams*)par)->hMutex);
    if(0 == result)
    {
        printErrorAndExit("ReleaseMutex");
    }
}

DWORD thirdThreadFunction(LPVOID par)
{
    int result = WaitForSingleObject(((struct ThreadParams*)par)->hMutex, INFINITE);
    if(WAIT_OBJECT_0 != result)
    {
        printErrorAndExit("WaitForSingleObject");
    }

    for(uint64_t i = 1; i < ((struct ThreadParams*)par)->fileSize; i+= 2)
    {
        ((struct ThreadParams*)par)->fileBuff[i] = '@';
    }

    result = ReleaseMutex(((struct ThreadParams*)par)->hMutex);
    if(0 == result)
    {
        printErrorAndExit("ReleaseMutex");
    }
}

int main()
{
    HANDLE fileMutex = CreateMutex(NULL, FALSE, NULL);
    if(0 == fileMutex)
    {
        printErrorAndExit("CreateMutex");
    }

    struct ThreadParams structIn = {fileMutex, FILE_SIZE, "out.txt", FileBuff};

    createFileAndFillRandomChars(FileName, FILE_SIZE);
    mapFileToRam(FileName, FILE_SIZE, FileBuff);

    int handles[3];

    handles[0] = CreateThread(0, 0, firstThreadFunction, &structIn, 0, 0);
    if(0 == handles[0])
    {
        printErrorAndExit("CreateThread");
    }

    handles[1] = CreateThread(0, 0, secondThreadFunction, &structIn, 0, 0);
    if(0 == handles[1])
    {
        printErrorAndExit("CreateThread");
    }

    handles[2] = CreateThread(0, 0, thirdThreadFunction, &structIn, 0, 0);
    if(0 == handles[2])
    {
        printErrorAndExit("CreateThread");
    }

    WaitForMultipleObjects(3, handles, 1, INFINITE);
}