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

    File: Runtime.hpp
    Date: 2021-6-9
    Author: Reece
***/
#pragma once

#if defined(AURORA_ENGINE_KERNEL_STATIC)
    #define AUKN_SYM
#else
    #if defined(AURORA_ENGINE_KERNEL_EXPORT)
        #define AUKN_SYM AURORA_SYMBOL_EXPORT
    #else
        #define AUKN_SYM AURORA_SYMBOL_IMPORT
    #endif
#endif

#include <auROXTL.hpp>

#if defined(_AUHAS_FMT)
    #include <fmt/core.h>
    #include <fmt/format.h>
    #include <fmt/chrono.h>
    #include <fmt/ranges.h>
#endif

#if !defined(_AUHAS_UUID)
    #error Missing stduuid library
#endif
#include <uuid.h>

#define AUKN_SHARED_API(name, type, ...) AU_SHARED_API_EX(AUKN_SYM, name, type, ## __VA_ARGS__)

#if defined(_AURORA_RUNTIME_BUILD_API_INTERFACES)
    #define AUKN_INTERFACE AUI_INTERFACE_IMPL
    #define AUKN_INTERFACE_EXT AUI_INTERFACE_EXT_IMPL
#else
    #define AUKN_INTERFACE AUI_INTERFACE_FWD
    #define AUKN_INTERFACE_EXT AUI_INTERFACE_EXT_FWD
#endif  

#include "Memory/Memory.hpp"

#include "Console/Console.hpp"
#include "Logging/Logging.hpp"
#include "Crypto/Crypto.hpp"
#include "Compression/Compression.hpp"
#include "Data/Data.hpp"
#include "Debug/Debug.hpp"
#include "Hashing/Hashing.hpp"
#include "HWInfo/HWInfo.hpp"
#include "IO/IO.hpp"
#include "Time/Time.hpp"
#include "Locale/Locale.hpp"
#include "Parse/Parse.hpp"
#include "Process/Process.hpp"
#include "Registry/Registry.hpp"
#include "RNG/RNG.hpp"
#include "Telemetry/Telemetery.hpp"
#include "Threading/Threading.hpp"
#include "Async/Async.hpp"
#include "Processes/Processes.hpp"
#include "IO/Loop/Loop.hpp"
#include "IO/IPC/IPC.hpp"
#include "SWInfo/SWInfo.hpp"
#include "Exit/Exit.hpp"
#include "CmdLine/CmdLine.hpp"
#include "Utility/RateLimiter.hpp"
#include "Memory/_ByteBuffer.hpp"

namespace AuAsync = Aurora::Async;
namespace AuBuild = Aurora::Build;
namespace AuCompression = Aurora::Compression;
namespace AuConsole = Aurora::Console;
namespace AuCmdLine = Aurora::CmdLine;
namespace AuCrypto = Aurora::Crypto;
namespace AuData = Aurora::Data;
namespace AuDebug = Aurora::Debug;
namespace AuThreading = Aurora::Threading;
namespace AuThreadPrimitives = Aurora::Threading::Primitives;
namespace AuThreads = Aurora::Threading::Threads;
namespace AuHwInfo = Aurora::HWInfo;
namespace AuSwInfo = Aurora::SWInfo;

namespace AuIO = Aurora::IO;
namespace AuIOFS = Aurora::IO::FS;
namespace AuIONet = Aurora::IO::Net;
namespace AuIOIPC = Aurora::IO::IPC;
namespace AuIOLoop = Aurora::IO::Loop;

// Legacy shorthands; wont deprecate
namespace AuIPC = Aurora::IO::IPC;
namespace AuLoop = Aurora::IO::Loop;
namespace AuNet = Aurora::IO::Net;
namespace AuFS = Aurora::IO::FS;

namespace AuRng = Aurora::RNG;
namespace AuLocale = Aurora::Locale;
namespace AuParse = Aurora::Parse;
namespace AuProcess = Aurora::Process;
namespace AuProcesses = Aurora::Processes;
namespace AuTelemetry = Aurora::Telemetry;
namespace AuTime = Aurora::Time;
namespace AuTypes = Aurora::Types;
namespace AuLog = Aurora::Logging;
namespace AuMemory = Aurora::Memory;
namespace AuExit = Aurora::Exit;

using AuWorkerId_t = AuAsync::WorkerId_t;
using AuWorkerPId_t = AuAsync::WorkerPId_t;

using AuByteBuffer = AuMemory::ByteBuffer;

using AuMemoryViewRead = AuMemory::MemoryViewRead;
using AuMemoryViewWrite = AuMemory::MemoryViewWrite;
using AuMemoryViewStreamRead = AuMemory::MemoryViewStreamRead;
using AuMemoryViewStreamWrite = AuMemory::MemoryViewStreamWrite;

static bool AuIsThreadRunning()
{
    return !AuThreads::GetThread()->Exiting();
}

static inline void AuDebugBreak()
{
    AuDebug::DebugBreak();
}

namespace Aurora
{
    struct LocalLogInfo
    {
        bool enableLogging       {true};
        bool autoCompressOldLogs {false};
        AuUInt32 maxSizeMB       {128 * 1024 * 1024}; // these numbers feel insane, but at least we have a max threshold
        int maxLogs              {1024};              // by default, we neither leak disk space or waste opportunities of being able to dig through old data
    #if defined(SHIP)
        bool writeLogsToUserDir  {true};              // use user directory
    #else
        bool writeLogsToUserDir  {false};             // use cwd
    #endif
    };

    struct TelemetryConfigDoc
    {
        LocalLogInfo localLogging;
        bool enabled                {false};
        
        AuString address;
        AuUInt16 port               {45069};
        AuString serviceIdnt        {"7b5f7a54-7122-4489-ac1a-3d75884b307e"};
        
        bool wantsActiveMonitoring  {false};
        
        bool privacyConsoleLog[255] {};
    };
    
    struct TelemetryConfig
    {
        bool readModNameJsonConfig {};
        TelemetryConfigDoc defaultConfig;
    };
    
    struct SocketConsole
    {
        bool enableLogging          {false};
        bool binaryProto            {false};
        AuString path;
        //AuIONet::ConnectionEndpoint net;
    };

    struct ConsoleConfig
    {
        /// Enables Aurora::Console::xxxStd functions; defer to enableStdXX for default logger behaviour
        bool enableStdPassthrough {false};
        
        /// Enables standard, debug, and GUI consoles
        bool enableConsole       {true};
        
        /// Attempt to force a terminal emulator host under graphical subsystems
        bool forceConsoleWindow  {};

        /// Attempt to force a GUI console under command line targets
        bool forceToolKitWindow  {};
        
        /// In conjunction with enableStdPassthrough, Aurora::Console::ReadStd reads a binary stream
        /// In conjunction with !enableStdPassthrough, enables stdin cmd processing, otherwise disables stdin input
        bool enableStdIn         {true};

        /// In conjunction with enableStdPassthrough, enables Aurora::Console::WriteStd to write binary, otherwise enables the console logger
        /// In conjunction with !enableStdPassthrough, enables stdout logging
        bool enableStdOut        {true};
        
        /// Use WxWidgets when possible
        bool enableWxWidgets     {true};

        /// Delegate stdout writes to loops -> recommended for servers
        bool asyncWrite {true};

        /// Async debug log
        bool asyncVSLog {false};
        
        /// Should stdout print the full date or a mere HH MM SS prefix?
        bool stdOutShortTime {false};

    #if 1
        /// FIO config
        LocalLogInfo fio;
    #endif

        AuString titleBrand      = "Aurora SDK Sample";

        AuString supportPublic   {"https://git.reece.sx/AuroraSupport/AuroraRuntime/issues"};
        AuString supportInternal {"https://jira.reece.sx"};

        bool consoleTTYHasPerAppHistory {true};
    };

    struct LoggerConfig
    {
        /// FIO config
        LocalLogInfo fileConfiguration;

        /// Socket config
        SocketConsole socketConfiguration;
    };
    
    struct CryptoConfig
    {
        /// Defer to the rationales in the implementation
        bool allowChineseCerts {false};
        
        /// Defer to the rationales in the implementation
        bool allowRussianCerts {true};
        
        /// WIP
        bool allowHTTPRetrievalOfCerts {true};
        
        /// 
        bool enablePinning     {true};

        ///
        AuList<AuString> blacklistedCerts{};
        AuList<AuString> whitelistedCerts{};
    };
    
    struct AsyncConfig
    {
        bool     enableSchedularThread {true}; // turn this off to make your application lighter weight, turn this on for higher performance (+expensive) scheduling
        bool     enableSysPumpFreqnecy {false}; // turn this on to enable an async app's singleton threadpool to SysPump on worker id zero. Alternatively, use SetMainThreadForSysPumpScheduling once you have a thread pool and worker id.
        AuUInt32 threadPoolDefaultStackSize {};
        AuUInt32 schedularFrequency {2};  // * 0.5 or 1 MS depending on the platform
        AuUInt32 sysPumpFrequency   {25}; // x amount of schedularFrequencys
    };

    struct FIOConfig
    {
        /// You can bypass branding by assigning an empty string to 'defaultBrand'
        AuString defaultBrand = "Aurora SDK Sample";
    };

    struct DebugConfig
    {
        /**
         * @brief Precache/initialize symbols for printable stack traces under binaries not intended for shipping to consumers
        */
        bool nonshipPrecachesSymbols {true};

        /**
         * @brief Activates the internal AddVectoredExceptionHandler handler. Might conflict with DRM and other debugging utilities
        */
        bool enableWin32RootExceptionHandler {true};

        /**
         * @brief 
        */
        bool enableInjectedExceptionHandler {true};

        /**
         * @brief Causes a SysPanic
        */
        bool isMemoryErrorFatal {false};

        /**
         * @brief 
        */
        bool isExceptionThrowFatal {false};

        bool printExceptionStackTracesOut {true};
    };

    struct RuntimeStartInfo
    {
        ConsoleConfig console;
        CryptoConfig crypto;
        TelemetryConfig telemetry;
        AsyncConfig async;
        FIOConfig fio;
        DebugConfig debug;
        bool bFIODisableBatching {true};
    };
    
    /**
     * @brief Initializes Aurora Runtime for the first and only time 
     * @return 
    */
    AUKN_SYM void RuntimeStart(const RuntimeStartInfo &info);

    /**
     * @brief Querys the state of the DLL or Static Library
     * @return true after at least one RuntimeStart
    */
    AUKN_SYM bool RuntimeHasStarted();

    /**
     * @brief You have **one** opportunity to swap the system locality before it locked
     *        This can be used by platform gems to align the runtime language and decimal dot notation to a given locality
     * @return 
    */
    AUKN_SYM void RuntimeOverloadLocality(const AuPair<AuString, AuString> &locality);
    
    /**
     * @brief Cleans up Aurora Runtime regardless of the count of calls to RuntimeShutdown or RuntimeStart
     * @return 
    */
    AUKN_SYM void RuntimeShutdown();

    /**
     * @brief Single threaded main pump for GUI applications polling for non-async subsystem callbacks
     * @return 
    */
    AUKN_SYM void RuntimeSysPump();
}