AuroraRuntime/Source/Processes/Open.Win32.cpp

/***
    Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: Open.Win32.cpp
    Date: 2021-6-12
    Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include "Processes.hpp"
#include "Open.Win32.hpp"

#include <shellapi.h>
#include <tlhelp32.h>

#include <Source/IO/FS/FS.hpp>
#include "Objbase.h"
#include "shellapi.h"

namespace Aurora::Processes
{
    static AuList<AuString> gOpenItems;
    static AuThreadPrimitives::ConditionMutexUnique_t gCondMutex;
    static AuThreadPrimitives::ConditionVariableUnique_t gCondVariable;
    static AuThreads::ThreadUnique_t gOpenerThread;

    static void RunTasks()
    {
        AU_LOCK_GUARD(gCondMutex);

        while (AuIsThreadRunning())
        {
            try
            {
                for (const auto &open : gOpenItems)
                {
                    if (open.empty()) continue; // [*1]

                    ShellExecuteW(nullptr,
                                  AuIOFS::DirExists(open) ? L"explore" : L"open",
                                  Locale::ConvertFromUTF8(open).c_str(),
                                  nullptr,
                                  nullptr,
                                  SW_SHOWNORMAL);
                }
                gOpenItems.clear();
                gCondVariable->WaitForSignal();
            }
            catch (...)
            {
                Debug::PrintError();
                AuLogWarn("An error occurred while dispatching a ShellExecute runner frame");
            }
        }
    }

    static void OpenerThread()
    {
        CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
        RunTasks();
        CoUninitialize();
    }

    void InitWin32Opener()
    {
        gCondMutex = AuThreadPrimitives::ConditionMutexUnique();
        SysAssert(gCondMutex);

        gCondVariable = AuThreadPrimitives::ConditionVariableUnique(AuUnsafeRaiiToShared(gCondMutex));
        SysAssert(gCondVariable);

        gOpenerThread = AuThreads::ThreadUnique(AuThreads::ThreadInfo(
            AuMakeShared<AuThreads::IThreadVectorsFunctional>(AuThreads::IThreadVectorsFunctional::OnEntry_t(std::bind(OpenerThread)),
                                                              AuThreads::IThreadVectorsFunctional::OnExit_t{}),
            "COM ShellExecute Runner"
        ));
        SysAssert(gOpenerThread);

        gOpenerThread->Run();
    }

    void DeinitWin32Opener()
    {
        gOpenerThread->SendExitSignal();
        gCondVariable->Broadcast();
        gOpenerThread.reset();
        gCondVariable.reset();
        gCondMutex.reset();
    }

    AUKN_SYM void OpenUri(const AuString &uri)
    {
        AU_LOCK_GUARD(gCondMutex);
        AuTryInsert(gOpenItems, uri);
        gCondVariable->Broadcast();
    }

    AUKN_SYM void OpenFile(const AuString &file)
    {
        OpenUri(AuIOFS::NormalizePathRet(file));
    }
}


// TODO: Consider creating blocking apis whose return value is an IProcess (construct from ShellExecuteExW -> in.hProcess, or ("xdg-start", ...))
// For the most part, blocking for a specific application in the context of a protocol or file open request is a dated computing construct.
// Nowdays, opening an editor, mail client, or such like means poking a single executable that'll spawn a fuck ton of background workers, io threads,
// and other resources, to manage multiple instances of whatever the application deals with (think: editor tabs; browser windows; sendto: isnt a modal)

// [*1] :
// We probably ran out of memory.
// AuProcess/Open can safely drop as we expect shells to be kinda fucky and async
// 
// Case in point: Minecraft on Linux (would?) blocks when you click a link in chat
// 
//                Fuck tons of applications support clicking of links, in the case of TS and others, allowing for RCE.
//                In the case of MC and others, they don't even know if the operation blocks until the process closes.
//                Assuming non-blocking, the API returns false on failure; but if it's blocking, who knows what that
//                means... Nonzero exit code? Not enough resources? No error?
//                
//                Websites, programs, and scripts wouldn't know how to process "missing protocol handler,"
//                "not enough resources," "process crashed before pump," "shell busy." For the most part, we don't 
//                expect expect the developer to be aware of what happens after a request to open a resource is
//                requested. It's a lot of engineering effort for what should be fork, exec("start", ...)
//
//                Dropping invalid paths, out of memory during UTF8 conversion, and other IO issues is probably fine.
//                Use an actual IProcess object, if you care about spawning and monitoring executables. 


// TODO: Move the above comments into something less gross