// tools/build.cpp - Fast native C++ build orchestrator for Juliet project
// Replaces all PowerShell scripts and orchestrates the full build process
#ifndef NOMINMAX
#define NOMINMAX
#endif
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <windows.h>

// ============================================================================
// Minimal string / path helpers (no STL, no std::filesystem — pure speed)
// ============================================================================

static constexpr int MaxPath        = 1024;
static constexpr int MaxFiles       = 4096;
static constexpr int MaxHashEntries = 512;

struct FixedString
{
    char Data[MaxPath];
    int  Length;

    FixedString()
      : Data{}
      , Length(0)
    {
    }

    void Set(const char* str)
    {
        assert(str != nullptr);
        Length = 0;
        while (str[Length] != '\0' && Length < MaxPath - 1)
        {
            Data[Length] = str[Length];
            Length++;
        }
        Data[Length] = '\0';
    }

    void Set(const char* str, int len)
    {
        assert(str != nullptr);
        assert(len >= 0 && len < MaxPath);
        for (int i = 0; i < len; i++)
        {
            Data[i] = str[i];
        }
        Data[len] = '\0';
        Length    = len;
    }

    void Append(const char* str)
    {
        assert(str != nullptr);
        int i = 0;
        while (str[i] != '\0' && Length < MaxPath - 1)
        {
            Data[Length++] = str[i++];
        }
        Data[Length] = '\0';
    }

    void AppendChar(char c)
    {
        if (Length < MaxPath - 1)
        {
            Data[Length++] = c;
            Data[Length]   = '\0';
        }
    }

    [[nodiscard]] bool Equals(const char* other) const
    {
        assert(other != nullptr);
        return strcmp(Data, other) == 0;
    }

    [[nodiscard]] bool EqualsNoCase(const char* other) const
    {
        assert(other != nullptr);
        return _stricmp(Data, other) == 0;
    }
};

[[nodiscard]] static bool StringContains(const char* haystack, const char* needle)
{
    assert(haystack != nullptr);
    assert(needle != nullptr);
    return strstr(haystack, needle) != nullptr;
}

[[nodiscard]] static bool EndsWithNoCase(const char* str, const char* suffix)
{
    assert(str != nullptr);
    assert(suffix != nullptr);
    int strLen = static_cast<int>(strlen(str));
    int sufLen = static_cast<int>(strlen(suffix));
    if (sufLen > strLen)
    {
        return false;
    }
    return _stricmp(str + strLen - sufLen, suffix) == 0;
}

// ============================================================================
// File I/O helpers using Win32
// ============================================================================

struct FileContent
{
    char* Data;
    DWORD Size;
};

[[nodiscard]] static FileContent ReadEntireFile(const char* path)
{
    assert(path != nullptr);
    FileContent result = { nullptr, 0 };
    HANDLE      file   = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING,
                                     FILE_ATTRIBUTE_NORMAL, nullptr);
    if (file == INVALID_HANDLE_VALUE)
    {
        return result;
    }
    DWORD size = GetFileSize(file, nullptr);
    if (size == INVALID_FILE_SIZE || size == 0)
    {
        CloseHandle(file);
        return result;
    }
    char* buffer = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, size + 1));
    if (buffer == nullptr)
    {
        CloseHandle(file);
        return result;
    }
    DWORD bytesRead = 0;
    ReadFile(file, buffer, size, &bytesRead, nullptr);
    CloseHandle(file);
    buffer[bytesRead] = '\0';
    result.Data       = buffer;
    result.Size       = bytesRead;
    return result;
}

static void FreeFileContent(FileContent& content)
{
    if (content.Data != nullptr)
    {
        HeapFree(GetProcessHeap(), 0, content.Data);
        content.Data = nullptr;
        content.Size = 0;
    }
}

static bool WriteEntireFile(const char* path, const char* data, DWORD size)
{
    assert(path != nullptr);
    assert(data != nullptr);
    HANDLE file = CreateFileA(path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS,
                              FILE_ATTRIBUTE_NORMAL, nullptr);
    if (file == INVALID_HANDLE_VALUE)
    {
        return false;
    }
    DWORD written = 0;
    WriteFile(file, data, size, &written, nullptr);
    CloseHandle(file);
    return written == size;
}

[[nodiscard]] static bool FileExists(const char* path)
{
    assert(path != nullptr);
    DWORD attribs = GetFileAttributesA(path);
    return (attribs != INVALID_FILE_ATTRIBUTES) && !(attribs & FILE_ATTRIBUTE_DIRECTORY);
}

[[nodiscard]] static bool DirectoryExists(const char* path)
{
    assert(path != nullptr);
    DWORD attribs = GetFileAttributesA(path);
    return (attribs != INVALID_FILE_ATTRIBUTES) && (attribs & FILE_ATTRIBUTE_DIRECTORY);
}

static void EnsureDirectoryExists(const char* path)
{
    assert(path != nullptr);
    CreateDirectoryA(path, nullptr);
}

[[nodiscard]] static int64_t GetFileModTimeInt64(const char* path)
{
    assert(path != nullptr);
    WIN32_FILE_ATTRIBUTE_DATA data;
    if (GetFileAttributesExA(path, GetFileExInfoStandard, &data))
    {
        ULARGE_INTEGER li;
        li.LowPart  = data.ftLastWriteTime.dwLowDateTime;
        li.HighPart = data.ftLastWriteTime.dwHighDateTime;
        return static_cast<int64_t>(li.QuadPart);
    }
    return 0;
}

// ============================================================================
// FNV-1a hash
// ============================================================================

[[nodiscard]] static uint64_t ComputeFnv1aHash(const char* data, DWORD size)
{
    assert(data != nullptr);
    uint64_t hash = 14695981039346656037ULL;
    for (DWORD i = 0; i < size; i++)
    {
        hash ^= static_cast<uint64_t>(static_cast<unsigned char>(data[i]));
        hash *= 1099511628211ULL;
    }
    return hash;
}

// ============================================================================
// Hash cache for unity files
// ============================================================================

struct HashEntry
{
    FixedString Path;
    char        HashStr[32];
};

struct HashCache
{
    HashEntry* Entries;
    int        Count;

    HashCache()
    {
        Entries = static_cast<HashEntry*>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HashEntry) * MaxHashEntries));
        assert(Entries != nullptr);
        Count = 0;
    }

    ~HashCache()
    {
        if (Entries != nullptr)
        {
            HeapFree(GetProcessHeap(), 0, Entries);
            Entries = nullptr;
        }
    }

    HashCache(const HashCache&)            = delete;
    HashCache& operator=(const HashCache&) = delete;

    [[nodiscard]] const char* Find(const char* path) const
    {
        assert(path != nullptr);
        for (int i = 0; i < Count; i++)
        {
            if (Entries[i].Path.Equals(path))
            {
                return Entries[i].HashStr;
            }
        }
        return nullptr;
    }

    void Add(const char* path, const char* hash)
    {
        assert(path != nullptr);
        assert(hash != nullptr);
        if (Count < MaxHashEntries && Entries != nullptr)
        {
            Entries[Count].Path.Set(path);
            strncpy_s(Entries[Count].HashStr, hash, sizeof(Entries[Count].HashStr) - 1);
            Count++;
        }
    }
};

static void LoadHashCache(const char* cachePath, HashCache& cache)
{
    assert(cachePath != nullptr);
    FileContent content = ReadEntireFile(cachePath);
    if (content.Data == nullptr)
    {
        return;
    }

    const char* pos = content.Data;
    while (*pos != '\0')
    {
        const char* lineStart = pos;
        while (*pos != '\0' && *pos != '\n' && *pos != '\r')
        {
            pos++;
        }
        int lineLen = static_cast<int>(pos - lineStart);

        if (lineLen > 0)
        {
            const char* sep = nullptr;
            for (const char* c = lineStart; c < lineStart + lineLen; c++)
            {
                if (*c == '=')
                {
                    sep = c;
                    break;
                }
            }
            if (sep != nullptr)
            {
                FixedString key;
                key.Set(lineStart, static_cast<int>(sep - lineStart));

                int  valLen  = static_cast<int>((lineStart + lineLen) - (sep + 1));
                char val[32] = {};
                if (valLen > 0 && valLen < 32)
                {
                    memcpy(val, sep + 1, static_cast<size_t>(valLen));
                    val[valLen] = '\0';
                }
                cache.Add(key.Data, val);
            }
        }

        while (*pos == '\n' || *pos == '\r')
        {
            pos++;
        }
    }

    FreeFileContent(content);
}

static void SaveHashCache(const char* cachePath, const HashCache& cache)
{
    assert(cachePath != nullptr);
    size_t bufSize = static_cast<size_t>(MaxHashEntries) * (MaxPath + 32 + 2);
    char*  buffer  = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, bufSize));
    if (buffer == nullptr)
    {
        return;
    }
    int offset = 0;

    for (int i = 0; i < cache.Count; i++)
    {
        int written = sprintf_s(buffer + offset, bufSize - static_cast<size_t>(offset), "%s=%s\n",
                                cache.Entries[i].Path.Data, cache.Entries[i].HashStr);
        if (written > 0)
        {
            offset += written;
        }
    }

    WriteEntireFile(cachePath, buffer, static_cast<DWORD>(offset));
    HeapFree(GetProcessHeap(), 0, buffer);
}

// ============================================================================
// Clean #pragma message lines and compute hash for a unity file
// ============================================================================

struct CleanResult
{
    char HashStr[32];
    bool WasCleaned;
};

[[nodiscard]] static CleanResult CleanAndHashUnityFile(const char* filePath)
{
    assert(filePath != nullptr);
    CleanResult result = { {}, false };

    FileContent content = ReadEntireFile(filePath);
    if (content.Data == nullptr)
    {
        result.HashStr[0] = '\0';
        return result;
    }

    bool hasPragma = StringContains(content.Data, "#pragma message");

    if (hasPragma)
    {
        // Filter out #pragma message lines
        char* filtered = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, content.Size + 1));
        assert(filtered != nullptr);
        DWORD filteredSize = 0;

        const char* pos = content.Data;
        while (*pos != '\0')
        {
            const char* lineStart = pos;
            while (*pos != '\0' && *pos != '\n')
            {
                pos++;
            }
            bool skipLine = false;
            for (const char* c = lineStart; c < pos; c++)
            {
                if (c + 15 <= content.Data + content.Size && memcmp(c, "#pragma message", 15) == 0)
                {
                    skipLine = true;
                    break;
                }
            }
            if (!skipLine)
            {
                DWORD lineLen = static_cast<DWORD>(pos - lineStart);
                memcpy(filtered + filteredSize, lineStart, lineLen);
                filteredSize += lineLen;
                if (*pos == '\n')
                {
                    filtered[filteredSize++] = '\n';
                }
            }
            if (*pos == '\n')
            {
                pos++;
            }
        }
        filtered[filteredSize] = '\0';

        WriteEntireFile(filePath, filtered, filteredSize);

        uint64_t hashVal = ComputeFnv1aHash(filtered, filteredSize);
        sprintf_s(result.HashStr, "%llu", hashVal);
        result.WasCleaned = true;

        HeapFree(GetProcessHeap(), 0, filtered);
    }
    else
    {
        uint64_t hashVal = ComputeFnv1aHash(content.Data, content.Size);
        sprintf_s(result.HashStr, "%llu", hashVal);
    }

    FreeFileContent(content);
    return result;
}

// ============================================================================
// Recursive directory scan for newest source file time
// ============================================================================

[[nodiscard]] static int64_t GetNewestSourceTimeRecursive(const char* dirPath)
{
    assert(dirPath != nullptr);
    int64_t newest = 0;

    if (!DirectoryExists(dirPath))
    {
        return newest;
    }

    FixedString searchPath;
    searchPath.Set(dirPath);
    searchPath.Append("\\*");

    WIN32_FIND_DATAA findData;
    HANDLE           hFind = FindFirstFileA(searchPath.Data, &findData);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        return newest;
    }

    do
    {
        if (findData.cFileName[0] == '.' &&
            (findData.cFileName[1] == '\0' || (findData.cFileName[1] == '.' && findData.cFileName[2] == '\0')))
        {
            continue;
        }

        FixedString fullPath;
        fullPath.Set(dirPath);
        fullPath.AppendChar('\\');
        fullPath.Append(findData.cFileName);

        if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            int64_t subNewest = GetNewestSourceTimeRecursive(fullPath.Data);
            if (subNewest > newest)
            {
                newest = subNewest;
            }
        }
        else
        {
            if (EndsWithNoCase(findData.cFileName, ".cpp") || EndsWithNoCase(findData.cFileName, ".h") ||
                EndsWithNoCase(findData.cFileName, ".hpp") || EndsWithNoCase(findData.cFileName, ".inl") ||
                EndsWithNoCase(findData.cFileName, ".c"))
            {
                ULARGE_INTEGER li;
                li.LowPart  = findData.ftLastWriteTime.dwLowDateTime;
                li.HighPart = findData.ftLastWriteTime.dwHighDateTime;
                int64_t ft  = static_cast<int64_t>(li.QuadPart);
                if (ft > newest)
                {
                    newest = ft;
                }
            }
        }
    }
    while (FindNextFileA(hFind, &findData));

    FindClose(hFind);
    return newest;
}

// ============================================================================
// Collect unity files recursively from Intermediate/
// ============================================================================

struct FilePathList
{
    FixedString* Paths;
    int          Count;

    FilePathList()
    {
        Paths = static_cast<FixedString*>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FixedString) * MaxFiles));
        assert(Paths != nullptr);
        Count = 0;
    }

    ~FilePathList()
    {
        if (Paths != nullptr)
        {
            HeapFree(GetProcessHeap(), 0, Paths);
            Paths = nullptr;
        }
    }

    FilePathList(const FilePathList&)            = delete;
    FilePathList& operator=(const FilePathList&) = delete;

    void Add(const char* path)
    {
        assert(path != nullptr);
        if (Count < MaxFiles && Paths != nullptr)
        {
            Paths[Count].Set(path);
            Count++;
        }
    }
};

static void CollectUnityFiles(const char* dirPath, FilePathList& list)
{
    assert(dirPath != nullptr);
    FixedString searchPath;
    searchPath.Set(dirPath);
    searchPath.Append("\\*");

    WIN32_FIND_DATAA findData;
    HANDLE           hFind = FindFirstFileA(searchPath.Data, &findData);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        return;
    }

    do
    {
        if (findData.cFileName[0] == '.' &&
            (findData.cFileName[1] == '\0' || (findData.cFileName[1] == '.' && findData.cFileName[2] == '\0')))
        {
            continue;
        }

        FixedString fullPath;
        fullPath.Set(dirPath);
        fullPath.AppendChar('\\');
        fullPath.Append(findData.cFileName);

        if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            CollectUnityFiles(fullPath.Data, list);
        }
        else
        {
            if (StringContains(findData.cFileName, "_Unity") && EndsWithNoCase(findData.cFileName, ".cpp"))
            {
                list.Add(fullPath.Data);
            }
        }
    }
    while (FindNextFileA(hFind, &findData));

    FindClose(hFind);
}

// ============================================================================
// Commands
// ============================================================================

struct BuildStep {
    char StepName[256];
    char OutputFile[MaxPath];
    char Depends[MaxPath];
    char Command[MaxFiles];
};

struct BuildConfig {
    char Name[64];
    char FastBuildTargets[512];
    BuildStep Steps[32];
    int StepCount;
};

static int CommandRunPlan(int argc, char* argv[])
{
    if (argc < 3)
    {
        printf("[ERROR] Usage: build_system run_plan <plan_file.txt>\n");
        return 1;
    }
    const char* planFile = argv[2];
    
    FileContent planContent = ReadEntireFile(planFile);
    if (!planContent.Data)
    {
        printf("[ERROR] Could not read build plan: %s\n", planFile);
        return 1;
    }

    EnsureDirectoryExists("Intermediate");
    DeleteFileA("Intermediate\\step_timings.tmp");
    DeleteFileA("Intermediate\\built_outputs.tmp");

    LARGE_INTEGER perfStart, perfEnd, perfFreq;
    QueryPerformanceCounter(&perfStart);
    QueryPerformanceFrequency(&perfFreq);

    // Parse plan file
    BuildConfig configs[4] = {};
    int configCount = 0;
    
    const char* pos = planContent.Data;
    while (*pos != '\0')
    {
        const char* lineStart = pos;
        while (*pos != '\0' && *pos != '\n' && *pos != '\r') pos++;
        int lineLen = static_cast<int>(pos - lineStart);
        
        if (lineLen > 0)
        {
            if (lineLen > 7 && memcmp(lineStart, "CONFIG ", 7) == 0)
            {
                if (configCount < 4)
                {
                    int nLen = lineLen - 7;
                    if (nLen >= static_cast<int>(sizeof(configs[configCount].Name))) nLen = static_cast<int>(sizeof(configs[configCount].Name)) - 1;
                    memcpy(configs[configCount].Name, lineStart + 7, nLen);
                    configs[configCount].Name[nLen] = '\0';
                    configCount++;
                }
            }
            else if (configCount > 0)
            {
                BuildConfig& curCfg = configs[configCount - 1];
                if (lineLen > 10 && memcmp(lineStart, "FASTBUILD ", 10) == 0)
                {
                    int nLen = lineLen - 10;
                    if (nLen >= static_cast<int>(sizeof(curCfg.FastBuildTargets))) nLen = static_cast<int>(sizeof(curCfg.FastBuildTargets)) - 1;
                    memcpy(curCfg.FastBuildTargets, lineStart + 10, nLen);
                    curCfg.FastBuildTargets[nLen] = '\0';
                }
                else if (lineLen > 5 && memcmp(lineStart, "STEP ", 5) == 0)
                {
                    if (curCfg.StepCount < 32)
                    {
                        int nLen = lineLen - 5;
                        if (nLen >= static_cast<int>(sizeof(curCfg.Steps[curCfg.StepCount].StepName))) nLen = static_cast<int>(sizeof(curCfg.Steps[curCfg.StepCount].StepName)) - 1;
                        memcpy(curCfg.Steps[curCfg.StepCount].StepName, lineStart + 5, nLen);
                        curCfg.Steps[curCfg.StepCount].StepName[nLen] = '\0';
                        curCfg.StepCount++;
                    }
                }
                else if (lineLen > 7 && memcmp(lineStart, "OUTPUT ", 7) == 0 && curCfg.StepCount > 0)
                {
                    int nLen = lineLen - 7;
                    if (nLen >= static_cast<int>(sizeof(curCfg.Steps[curCfg.StepCount - 1].OutputFile))) nLen = static_cast<int>(sizeof(curCfg.Steps[curCfg.StepCount - 1].OutputFile)) - 1;
                    memcpy(curCfg.Steps[curCfg.StepCount - 1].OutputFile, lineStart + 7, nLen);
                    curCfg.Steps[curCfg.StepCount - 1].OutputFile[nLen] = '\0';
                }
                else if (lineLen > 8 && memcmp(lineStart, "DEPENDS ", 8) == 0 && curCfg.StepCount > 0)
                {
                    int nLen = lineLen - 8;
                    if (nLen >= static_cast<int>(sizeof(curCfg.Steps[curCfg.StepCount - 1].Depends))) nLen = static_cast<int>(sizeof(curCfg.Steps[curCfg.StepCount - 1].Depends)) - 1;
                    memcpy(curCfg.Steps[curCfg.StepCount - 1].Depends, lineStart + 8, nLen);
                    curCfg.Steps[curCfg.StepCount - 1].Depends[nLen] = '\0';
                }
                else if (lineLen > 8 && memcmp(lineStart, "COMMAND ", 8) == 0 && curCfg.StepCount > 0)
                {
                    int nLen = lineLen - 8;
                    if (nLen >= static_cast<int>(sizeof(curCfg.Steps[curCfg.StepCount - 1].Command))) nLen = static_cast<int>(sizeof(curCfg.Steps[curCfg.StepCount - 1].Command)) - 1;
                    memcpy(curCfg.Steps[curCfg.StepCount - 1].Command, lineStart + 8, nLen);
                    curCfg.Steps[curCfg.StepCount - 1].Command[nLen] = '\0';
                }
            }
        }
        while (*pos == '\n' || *pos == '\r') pos++;
    }
    FreeFileContent(planContent);

    bool anyBuilt = false;
    char timingsBuf[MaxFiles * 2] = {};
    int timingsLen = 0;
    
    auto AppendTiming = [&](const char* stepName, double secs)
    {
        timingsLen += sprintf_s(timingsBuf + timingsLen, sizeof(timingsBuf) - timingsLen, "%s|%.3fs\n", stepName, secs);
    };

    auto ExecuteCmd = [](const char* cmdLine) -> int
    {
        STARTUPINFOA si;
        memset(&si, 0, sizeof(si));
        si.cb = sizeof(si);
        PROCESS_INFORMATION pi = {};
        DWORD exitCode = 1;
        
        char* cmdBuf = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, MaxFiles));
        if (!cmdBuf) return 1;
        strcpy_s(cmdBuf, MaxFiles, cmdLine);
        
        if (CreateProcessA(nullptr, cmdBuf, nullptr, nullptr, TRUE, 0, nullptr, nullptr, &si, &pi))
        {
            WaitForSingleObject(pi.hProcess, INFINITE);
            GetExitCodeProcess(pi.hProcess, &exitCode);
            CloseHandle(pi.hProcess);
            CloseHandle(pi.hThread);
        }
        else
        {
            printf("[ERROR] Failed to execute command.\n");
            HeapFree(GetProcessHeap(), 0, cmdBuf);
            return 1;
        }
        HeapFree(GetProcessHeap(), 0, cmdBuf);
        return static_cast<int>(exitCode);
    };

    for (int i = 0; i < configCount; i++)
    {
        BuildConfig& cfg = configs[i];
        printf("\n==============================================================================\n");
        printf("Generating Unity Files into Intermediate/ via FASTBuild [%s]...\n", cfg.Name);
        printf("==============================================================================\n");

        if (cfg.FastBuildTargets[0] != '\0')
        {
            char fbuildCmd[MaxPath];
            sprintf_s(fbuildCmd, sizeof(fbuildCmd), "misc\\fbuild.exe %s", cfg.FastBuildTargets);
            
            LARGE_INTEGER tStart, tEnd;
            QueryPerformanceCounter(&tStart);
            int res = ExecuteCmd(fbuildCmd);
            QueryPerformanceCounter(&tEnd);
            
            char stepName[MaxPath];
            sprintf_s(stepName, sizeof(stepName), "FASTBuild Unity Gen [%s]", cfg.Name);
            AppendTiming(stepName, static_cast<double>(tEnd.QuadPart - tStart.QuadPart) / static_cast<double>(perfFreq.QuadPart));
            
            if (res != 0)
            {
                printf("[BUILD FAILED] FASTBuild failed for %s.\n", cfg.Name);
                return res;
            }
        }

        HashCache oldCache;
        LoadHashCache("Intermediate\\.unity_hashes_cache", oldCache);
        
        HashCache newCache;
        bool unityChanged = false;
        
        FilePathList unityFiles;
        CollectUnityFiles("Intermediate", unityFiles);
        
        if (unityFiles.Count == 0)
        {
            unityChanged = true;
        }
        else
        {
            for (int k = 0; k < unityFiles.Count; k++)
            {
                CleanResult cr = CleanAndHashUnityFile(unityFiles.Paths[k].Data);
                newCache.Add(unityFiles.Paths[k].Data, cr.HashStr);
                
                const char* oldHash = oldCache.Find(unityFiles.Paths[k].Data);
                if (oldHash == nullptr || strcmp(oldHash, cr.HashStr) != 0)
                {
                    unityChanged = true;
                }
            }
        }
        SaveHashCache("Intermediate\\.unity_hashes_cache", newCache);

        if (unityChanged)
        {
            printf("[FASTBuild] Unity structure or source file list changed.\n");
        }
        else
        {
            printf("[FASTBuild] No Unity file structure changes detected [up-to-date].\n");
        }

        printf("\n==============================================================================\n");
        printf("Compiling Targets [%s]...\n", cfg.Name);
        printf("==============================================================================\n");

        struct DirCacheEntry { FixedString Path; int64_t Time; };
        DirCacheEntry dirCache[64];
        int dirCacheCount = 0;
        
        auto GetDirTime = [&](const char* dir) -> int64_t
        {
            for (int k = 0; k < dirCacheCount; k++)
            {
                if (dirCache[k].Path.EqualsNoCase(dir)) return dirCache[k].Time;
            }
            int64_t t = GetNewestSourceTimeRecursive(dir);
            if (dirCacheCount < 64)
            {
                dirCache[dirCacheCount].Path.Set(dir);
                dirCache[dirCacheCount].Time = t;
                dirCacheCount++;
            }
            return t;
        };

        bool anyNeedBuild = false;

        for (int j = 0; j < cfg.StepCount; j++)
        {
            BuildStep& step = cfg.Steps[j];
            int64_t maxTime = 0;
            const char* cur = step.Depends;
            while (*cur)
            {
                const char* nextPipe = strchr(cur, '|');
                char dirPath[MaxPath] = {};
                if (nextPipe)
                {
                    int dLen = static_cast<int>(nextPipe - cur);
                    if (dLen >= static_cast<int>(sizeof(dirPath))) dLen = static_cast<int>(sizeof(dirPath)) - 1;
                    memcpy(dirPath, cur, dLen);
                    dirPath[dLen] = '\0';
                    cur = nextPipe + 1;
                }
                else
                {
                    strcpy_s(dirPath, sizeof(dirPath), cur);
                    cur += strlen(cur);
                }
                if (dirPath[0] != '\0')
                {
                    int64_t t = GetDirTime(dirPath);
                    if (t > maxTime) maxTime = t;
                }
            }

            bool needCompile = unityChanged;
            if (!needCompile)
            {
                if (!FileExists(step.OutputFile))
                {
                    needCompile = true;
                }
                else
                {
                    int64_t outTime = GetFileModTimeInt64(step.OutputFile);
                    if (outTime < maxTime) needCompile = true;
                }
            }

            printf("\n--- %s ---\n", step.StepName);
            if (!needCompile)
            {
                printf("[SKIP / UP-TO-DATE] %s [Binary up to date]\n", step.OutputFile);
            }
            else
            {
                printf("[REBUILDING] Compiling %s...\n", step.OutputFile);
                anyNeedBuild = true;
                
                LARGE_INTEGER tStart, tEnd;
                QueryPerformanceCounter(&tStart);
                int res = ExecuteCmd(step.Command);
                QueryPerformanceCounter(&tEnd);
                
                AppendTiming(step.StepName, static_cast<double>(tEnd.QuadPart - tStart.QuadPart) / static_cast<double>(perfFreq.QuadPart));
                
                if (res != 0)
                {
                    printf("[BUILD FAILED] Command failed with exit code %d.\n", res);
                    return res;
                }
                
                char builtOut[MaxPath + 2];
                sprintf_s(builtOut, "%s\n", step.OutputFile);
                
                HANDLE hFile = CreateFileA("Intermediate\\built_outputs.tmp", FILE_APPEND_DATA, FILE_SHARE_READ, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
                if (hFile != INVALID_HANDLE_VALUE)
                {
                    DWORD written = 0;
                    WriteFile(hFile, builtOut, static_cast<DWORD>(strlen(builtOut)), &written, nullptr);
                    CloseHandle(hFile);
                }
                anyBuilt = true;
            }
        }
        
        if (!anyNeedBuild)
        {
            printf("\n[SKIP / UP-TO-DATE] All requested targets in [%s] are up-to-date.\n", cfg.Name);
        }
    }

    if (timingsLen > 0)
    {
        WriteEntireFile("Intermediate\\step_timings.tmp", timingsBuf, timingsLen);
    }

    QueryPerformanceCounter(&perfEnd);
    double elapsedSeconds = static_cast<double>(perfEnd.QuadPart - perfStart.QuadPart) / static_cast<double>(perfFreq.QuadPart);

    char elapsedBuf[64];
    if (elapsedSeconds < 60.0)
    {
        sprintf_s(elapsedBuf, "%.3fs", elapsedSeconds);
    }
    else
    {
        int totalMs = static_cast<int>(elapsedSeconds * 1000.0);
        int hours = totalMs / 3600000;
        int minutes = (totalMs % 3600000) / 60000;
        int seconds = (totalMs % 60000) / 1000;
        int ms = totalMs % 1000;
        sprintf_s(elapsedBuf, "%02d:%02d:%02d.%03d", hours, minutes, seconds, ms);
    }

    printf("\n==============================================================================\n");
    printf("[BUILD SUMMARY]\n");
    printf("==============================================================================\n");
    
    if (timingsLen > 0)
    {
        printf("Step Timings:\n");
        const char* pos = timingsBuf;
        while (*pos)
        {
            const char* lineStart = pos;
            while (*pos && *pos != '\n') pos++;
            int len = static_cast<int>(pos - lineStart);
            if (len > 0)
            {
                const char* pipe = strchr(lineStart, '|');
                if (pipe && pipe < pos)
                {
                    char stepName[MaxPath] = {};
                    int nameLen = static_cast<int>(pipe - lineStart);
                    memcpy(stepName, lineStart, nameLen);
                    
                    char durStr[64] = {};
                    int durLen = static_cast<int>(pos - (pipe + 1));
                    memcpy(durStr, pipe + 1, durLen);
                    
                    printf("  - %-42s : %s\n", stepName, durStr);
                }
            }
            if (*pos == '\n') pos++;
        }
        printf("------------------------------------------------------------------------------\n");
    }

    printf("Total Duration : %s\n", elapsedBuf);
    printf("Output Binaries:\n");

    if (anyBuilt)
    {
        FileContent outputsContent = ReadEntireFile("Intermediate\\built_outputs.tmp");
        if (outputsContent.Data)
        {
            const char* pos = outputsContent.Data;
            while (*pos)
            {
                const char* lineStart = pos;
                while (*pos && *pos != '\n' && *pos != '\r') pos++;
                int len = static_cast<int>(pos - lineStart);
                if (len > 0)
                {
                    char filePath[MaxPath] = {};
                    memcpy(filePath, lineStart, len);
                    WIN32_FILE_ATTRIBUTE_DATA fileData;
                    if (GetFileAttributesExA(filePath, GetFileExInfoStandard, &fileData))
                    {
                        ULARGE_INTEGER fileSize;
                        fileSize.LowPart = fileData.nFileSizeLow;
                        fileSize.HighPart = fileData.nFileSizeHigh;
                        double sizeMB = static_cast<double>(fileSize.QuadPart) / (1024.0 * 1024.0);
                        printf("  - %s (%.2f MB)\n", filePath, sizeMB);
                    }
                }
                while (*pos == '\n' || *pos == '\r') pos++;
            }
            FreeFileContent(outputsContent);
        }
        DeleteFileA("Intermediate\\built_outputs.tmp");
    }
    else
    {
        printf("  - None built in this session (all requested targets up-to-date)\n");
    }
    
    printf("==============================================================================\n");
    printf("[ALL BUILDS SUCCEEDED] All requested targets processed successfully.\n");
    printf("==============================================================================\n");
    fflush(stdout);

    return 0;
}

// ============================================================================
// Main entry point
// ============================================================================

int main(int argc, char* argv[])
{
    if (argc < 2)
    {
        printf("Usage: build_system <command> [args...]\n");
        printf("Commands:\n");
        printf("  run_plan <plan_file>     Run the build from a generated plan file\n");
        printf("  check_alive              Returns 0 immediately to test execution\n");
        return 1;
    }

    const char* cmd = argv[1];
    if (strcmp(cmd, "check_alive") == 0) return 0;
    if (strcmp(cmd, "run_plan") == 0) return CommandRunPlan(argc, argv);

    printf("[ERROR] Unknown command: %s\n", cmd);
    return 1;
}