/*
Crafter® Build
Copyright (C) 2026 Catcrafts®
Catcrafts.net

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation;

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
*/

module Crafter.Build:Module_impl;
import std;
import :Module;
import :Command;
namespace fs = std::filesystem;

namespace Crafter {
    ModulePartition::ModulePartition(std::string&& name, fs::path&& path) : name(std::move(name)), path(std::move(path)), compiled(CRAFTER_COMPILE_STATUS_WAITING), checked(false) {}

    bool ModulePartition::Check(const fs::path& pcmDir) {
        if(!checked) {
            checked = true;
            if(fs::exists((pcmDir/path.filename()).generic_string()+".pcm") && fs::last_write_time(path.generic_string()+".cppm") < fs::last_write_time((pcmDir/path.filename()).generic_string()+".pcm")) {
                for(ModulePartition* dependency : partitionDependencies) {
                    if(dependency->Check(pcmDir)) {
                        needsRecompiling = true;
                        return true;
                    }
                }
                for(Module* dependency : moduleDependencies) {
                    if(dependency->Check(pcmDir)) {
                        needsRecompiling = true;
                        return true;
                    }
                }
                needsRecompiling = false;
                compiled.store(CRAFTER_COMPILE_STATUS_COMPLETED);
                return false;
            } else {
                needsRecompiling = true;
                return true;
            }
        } else {
            return needsRecompiling;
        }
    }

    void ModulePartition::Compile(const std::string_view clang, const fs::path& pcmDir, const fs::path& buildDir, std::string& result) {
        for(ModulePartition* dependency : partitionDependencies) {
            if(!dependency->compiled.load()) {
                //std::cout << std::format("{} is waiting on {} {}", name, dependency->name, dependency->needsRecompiling) << std::endl;
                dependency->compiled.wait(CRAFTER_COMPILE_STATUS_WAITING);
                if(dependency->compiled.load() == CRAFTER_COMPILE_STATUS_ERROR) {
                    compiled.store(CRAFTER_COMPILE_STATUS_ERROR);
                    compiled.notify_all();
                    return;
                }
            }
        }

        result += RunClang(std::format("{} {}.cppm --precompile -o {}.pcm", clang, path.string(), (pcmDir/path.filename()).string()));
        if(result.empty()) {
            compiled.store(CRAFTER_COMPILE_STATUS_COMPLETED);
            compiled.notify_all();
        } else {
            compiled.store(CRAFTER_COMPILE_STATUS_ERROR);
            compiled.notify_all();
        }
    }

    void ModulePartition::CompileSource(const std::string_view clang, const fs::path& pcmDir, const fs::path& buildDir, std::string& result) { 
        this->compiled.wait(CRAFTER_COMPILE_STATUS_WAITING);
        if(this->compiled.load() != CRAFTER_COMPILE_STATUS_ERROR) {
            result += RunClang(std::format("{} -Wno-unused-command-line-argument {}.pcm -c -o {}.o", clang, (pcmDir/path.filename()).string(), (buildDir/path.filename()).string()));
        }
    }

    Module::Module(std::string&& name, fs::path&& path, std::vector<std::unique_ptr<ModulePartition>>&& partitions) : name(std::move(name)), path(std::move(path)), partitions(std::move(partitions)), compiled(CRAFTER_COMPILE_STATUS_WAITING), checked(false) {}

    Module::Module(std::string&& name, fs::path&& path) : name(std::move(name)), path(std::move(path)), compiled(CRAFTER_COMPILE_STATUS_WAITING), checked(false) {}

    Module::Module(fs::path&& path) : path(std::move(path)), compiled(CRAFTER_COMPILE_STATUS_WAITING), checked(false) {
        std::ifstream t(this->path);
        std::stringstream buffer;
        buffer << t.rdbuf();
        std::string fileContent = buffer.str();
        fileContent = std::regex_replace(fileContent, std::regex(R"(//[^\n]*)"), "");
        fileContent = std::regex_replace(fileContent, std::regex(R"(/\*.*?\*/)"), "");
        std::smatch match;
        if (std::regex_search(fileContent, match, std::regex(R"(export module ([a-zA-Z0-9_.-]+);)"))) {
            name = match[1].str();
        } else {
            throw std::runtime_error(std::format("No module declaration found in {}", this->path.string()));
        }
    }

    bool Module::Check(const fs::path& pcmDir) {
        if(!checked) {
            checked = true;
            if(fs::exists((pcmDir/path.filename()).generic_string()+".pcm") && fs::last_write_time(path.generic_string()+".cppm") < fs::last_write_time((pcmDir/path.filename()).generic_string()+".pcm")) {
                bool depCheck = false;
                for(std::unique_ptr<ModulePartition>& partition : partitions) {
                    if(partition->Check(pcmDir)) {
                        depCheck = true;
                    }
                }
                if(depCheck) {
                    needsRecompiling = true;
                    return true;
                } else {
                    needsRecompiling = false;
                    compiled.store(CRAFTER_COMPILE_STATUS_COMPLETED);
                    return false;
                }
            } else {
                for(std::unique_ptr<ModulePartition>& partition : partitions) {
                    partition->Check(pcmDir);
                }
                needsRecompiling = true;
                return true;
            }
        } else {
            return needsRecompiling;
        }
    }

    void Module::Compile(const std::string_view clang, const fs::path& pcmDir, const fs::path& buildDir, std::string& result) {  
        std::vector<std::thread> threads;
        std::vector<std::string> results(partitions.size());
        for(std::uint_fast32_t i = 0; i < partitions.size(); i++) {
            if( partitions[i]->needsRecompiling) {
                threads.emplace_back(&ModulePartition::Compile, partitions[i].get(), clang, pcmDir, buildDir, std::ref(results[i]));
            }
        }

        for(std::thread& thread : threads){
            thread.join();
        }

        for(const std::string& result2 : results) {
            result += result2;
        }

        if(result.empty()) {
            result += RunClang(std::format("{} {}.cppm --precompile -o {}.pcm", clang, path.string(), (pcmDir/path.filename()).string()));
            if(result.empty()) {
                compiled.store(CRAFTER_COMPILE_STATUS_COMPLETED);
                compiled.notify_all();
            } else {
                compiled.store(CRAFTER_COMPILE_STATUS_ERROR);
                compiled.notify_all();
            }
        } else {
            compiled.store(CRAFTER_COMPILE_STATUS_ERROR);
            compiled.notify_all();
        }
    }

    void Module::CompileSource(const std::string_view clang, const fs::path& pcmDir, const fs::path& buildDir, std::string& result) {
        this->compiled.wait(CRAFTER_COMPILE_STATUS_WAITING);
        if(this->compiled.load() != CRAFTER_COMPILE_STATUS_ERROR) {
            result += RunClang(std::format("{} -Wno-unused-command-line-argument {}.pcm -c -o {}.o", clang, (pcmDir/path.filename()).string(), (buildDir/path.filename()).string()));
            std::vector<std::thread> threads;
            std::vector<std::string> results(partitions.size());
            for(std::uint_fast32_t i = 0; i < partitions.size(); i++) {
                if( partitions[i]->needsRecompiling) {
                    threads.emplace_back(&ModulePartition::CompileSource, partitions[i].get(), clang, pcmDir, buildDir, std::ref(results[i]));
                }
            }

            for(std::thread& thread : threads){
                thread.join();
            }

            for(const std::string& result2 : results) {
                result += result2;
            }
        }
    }
}
