#include "pch.h"
#include <ctime>
#include <mutex>
#include "strings.h"
#include "settings.h"
#include "type_writers.h"
#include "helpers.h"
#include "code_writers.h"
#include "component_writers.h"
#include "file_writers.h"
#include "type_writers.h"

namespace cppwinrt
{
    settings_type settings;

    struct usage_exception {};

    static constexpr option options[]
    {
        { "input", 0, option::no_max, "<spec>", "Windows metadata to include in projection" },
        { "reference", 0, option::no_max, "<spec>", "Windows metadata to reference from projection" },
        { "output", 0, 1, "<path>", "Location of generated projection and component templates" },
        { "component", 0, 1, "[<path>]", "Generate component templates, and optional implementation" },
        { "name", 0, 1, "<name>", "Specify explicit name for component files" },
        { "verbose", 0, 0, {}, "Show detailed progress information" },
        { "overwrite", 0, 0, {}, "Overwrite generated component files" },
        { "prefix", 0, 0, {}, "Use dotted namespace convention for component files (defaults to folders)" },
        { "pch", 0, 1, "<name>", "Specify name of precompiled header file (defaults to pch.h; use '.' to disable)" },
        { "include", 0, option::no_max, "<prefix>", "One or more prefixes to include in input" },
        { "exclude", 0, option::no_max, "<prefix>", "One or more prefixes to exclude from input" },
        { "base", 0, 0, {}, "Generate base.h unconditionally" },
        { "optimize", 0, 0, {}, "Generate component projection with unified construction support" },
        { "help", 0, option::no_max, {}, "Show detailed help with examples" },
        { "?", 0, option::no_max, {}, {} },
        { "library", 0, 1, "<prefix>", "Specify library prefix (defaults to winrt)" },
        { "filter" }, // One or more prefixes to include in input (same as -include)
        { "license", 0, 1, "[<path>]", "Generate license comment from template file" },
        { "brackets", 0, 0 }, // Use angle brackets for #includes (defaults to quotes)
        { "fastabi", 0, 0 }, // Enable support for the Fast ABI
        { "ignore_velocity", 0, 0 }, // Ignore feature staging metadata and always include implementations
        { "synchronous", 0, 0 }, // Instructs cppwinrt to run on a single thread to avoid file system issues in batch builds
        { "modules", 0, 0, {}, "Generate per-namespace C++20 module interface units (.ixx)" },
        { "module_include", 0, option::no_max, "<prefix>", "Filter which namespaces are included in module .ixx generation" },
        { "module_exclude", 0, option::no_max, "<prefix>", "Filter which namespaces are excluded from module .ixx generation" },
    };

    static void print_usage(writer& w)
    {
        static auto printColumns = [](writer& w, std::string_view const& col1, std::string_view const& col2)
        {
            w.write_printf("  %-20s%s\n", col1.data(), col2.data());
        };

        static auto printOption = [](writer& w, option const& opt)
        {
            if(opt.desc.empty())
            {
                return;
            }
            printColumns(w, w.write_temp("-% %", opt.name, opt.arg), opt.desc);
        };

        auto format = R"(
C++/WinRT v%
Copyright (c) Microsoft Corporation. All rights reserved.

  cppwinrt.exe [options...]

Options:

%  ^@<path>             Response file containing command line options

Where <spec> is one or more of:

  path                Path to winmd file or recursively scanned folder
)"
#if defined(_WIN32) || defined(_WIN64)
R"(  local               Local ^%WinDir^%\System32\WinMetadata folder
  sdk[+]              Current version of Windows SDK [with extensions]
  10.0.12345.0[+]     Specific version of Windows SDK [with extensions]
)"
#endif
        ;
        w.write(format, CPPWINRT_VERSION_STRING, bind_each(printOption, options));
    }

    static void process_args(reader const& args)
    {
        settings.verbose = args.exists("verbose");
        settings.fastabi = args.exists("fastabi");
        settings.modules = args.exists("modules");

        settings.input = args.files("input", database::is_database);
        settings.reference = args.files("reference", database::is_database);

        settings.component = args.exists("component");
        settings.base = args.exists("base");

        for (auto&& ns : args.values("module_include"))
        {
            settings.module_include.insert(ns);
        }
        for (auto&& ns : args.values("module_exclude"))
        {
            settings.module_exclude.insert(ns);
        }

        settings.license = args.exists("license");
        settings.brackets = args.exists("brackets");

        path output_folder = args.value("output", ".");
        create_directories(output_folder / "winrt/impl");
        settings.output_folder = canonical(output_folder).string();
        settings.output_folder += std::filesystem::path::preferred_separator;

        for (auto && include : args.values("include"))
        {
            settings.include.insert(include);
        }

        for (auto && include : args.values("filter"))
        {
            settings.include.insert(include);
        }

        for (auto && exclude : args.values("exclude"))
        {
            settings.exclude.insert(exclude);
        }

        if (settings.license)
        {
            std::string license_arg = args.value("license");
            if (license_arg.empty())
            {
                settings.license_template = R"(// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
)";
            }
            else
            {
                std::filesystem::path template_path{ license_arg };
                std::ifstream template_file(absolute(template_path));
                if (template_file.fail())
                {
                    throw_invalid("Cannot read license template file '", absolute(template_path).string() + "'");
                }
                std::string line_buf;
                while (getline(template_file, line_buf))
                {
                    if (line_buf.empty())
                    {
                        settings.license_template += "//\n";
                    }
                    else
                    {
                        settings.license_template += "// ";
                        settings.license_template += line_buf;
                        settings.license_template += "\n";
                    }
                }
            }
        }

        if (settings.component)
        {
            settings.component_overwrite = args.exists("overwrite");
            settings.component_name = args.value("name");

            if (settings.component_name.empty())
            {
                // For compatibility with C++/WinRT 1.0, the component_name defaults to the *first*
                // input, hence the use of values() here that will return the args in input order.

                auto& values = args.values("input");

                if (!values.empty())
                {
                    settings.component_name = path(values[0]).filename().replace_extension().string();
                }
            }

            settings.component_pch = args.value("pch", "pch.h");
            settings.component_prefix = args.exists("prefix");
            settings.component_lib = args.value("library", "winrt");
            settings.component_opt = args.exists("optimize");
            settings.component_ignore_velocity = args.exists("ignore_velocity");

            if (settings.component_pch == ".")
            {
                settings.component_pch.clear();
            }

            auto component = args.value("component");

            if (!component.empty())
            {
                create_directories(component);
                settings.component_folder = canonical(component).string();
                settings.component_folder += std::filesystem::path::preferred_separator;
            }
        }
    }

    static auto get_files_to_cache()
    {
        std::vector<std::string> files;
        files.insert(files.end(), settings.input.begin(), settings.input.end());
        files.insert(files.end(), settings.reference.begin(), settings.reference.end());
        return files;
    }

    static void build_filters(cache const& c)
    {
        // Build module_filter from -module_include / -module_exclude args.
        // This controls which namespaces get .ixx files without affecting header generation.
        if (!settings.module_include.empty() || !settings.module_exclude.empty())
        {
            settings.module_filter = { settings.module_include, settings.module_exclude };
        }

        if (settings.reference.empty())
        {
            return;
        }

        std::set<std::string> include;

        for (auto file : settings.input)
        {
            auto db = std::find_if(c.databases().begin(), c.databases().end(), [&](auto&& db)
            {
                return db.path() == file;
            });

            for (auto&& type : db->TypeDef)
            {
                if (!type.Flags().WindowsRuntime())
                {
                    continue;
                }

                std::string full_name{ type.TypeNamespace() };
                full_name += '.';
                full_name += type.TypeName();
                include.insert(full_name);
            }
        }

        settings.projection_filter = { include, {} };
        
        settings.component_filter = { settings.include.empty() ? include : settings.include, settings.exclude };
    }

    static void build_fastabi_cache(cache const& c)
    {
        if (!settings.fastabi)
        {
            return;
        }

        for (auto&& [ns, members] : c.namespaces())
        {
            for (auto&& type : members.classes)
            {
                if (!has_fastabi(type))
                {
                    continue;
                }

                auto default_interface = get_default_interface(type);

                if (default_interface.type() == TypeDefOrRef::TypeDef)
                {
                    settings.fastabi_cache.try_emplace(default_interface.TypeDef(), type);
                }
                else
                {
                    settings.fastabi_cache.try_emplace(find_required(default_interface.TypeRef()), type);
                }
            }
        }
    }

    static void remove_foundation_types(cache& c)
    {
        c.remove_type("Windows.Foundation", "DateTime");
        c.remove_type("Windows.Foundation", "EventRegistrationToken");
        c.remove_type("Windows.Foundation", "HResult");
        c.remove_type("Windows.Foundation", "Point");
        c.remove_type("Windows.Foundation", "Rect");
        c.remove_type("Windows.Foundation", "Size");
        c.remove_type("Windows.Foundation", "TimeSpan");

        c.remove_type("Windows.Foundation.Numerics", "Matrix3x2");
        c.remove_type("Windows.Foundation.Numerics", "Matrix4x4");
        c.remove_type("Windows.Foundation.Numerics", "Plane");
        c.remove_type("Windows.Foundation.Numerics", "Quaternion");
        c.remove_type("Windows.Foundation.Numerics", "Vector2");
        c.remove_type("Windows.Foundation.Numerics", "Vector3");
        c.remove_type("Windows.Foundation.Numerics", "Vector4");
    }

    // Tarjan's algorithm for finding strongly connected components in the
    // namespace dependency graph. Namespaces in an SCC have cyclic deps and
    // must be combined into a single module.
    static std::vector<std::vector<std::string>> find_sccs(
        std::map<std::string, std::set<std::string>, std::less<>> const& graph)
    {
        struct context
        {
            std::map<std::string, int> index_of;
            std::map<std::string, int> lowlink;
            std::map<std::string, bool> on_stack;
            std::vector<std::string> stack;
            int next_index = 0;
            std::vector<std::vector<std::string>> result;

            void strongconnect(std::string const& v,
                std::map<std::string, std::set<std::string>, std::less<>> const& g)
            {
                index_of[v] = next_index;
                lowlink[v] = next_index;
                next_index++;
                stack.push_back(v);
                on_stack[v] = true;

                auto it = g.find(v);
                if (it != g.end())
                {
                    for (auto& w : it->second)
                    {
                        if (g.find(w) == g.end())
                        {
                            continue; // dep not in graph (not a projected namespace)
                        }

                        if (index_of.find(w) == index_of.end())
                        {
                            strongconnect(w, g);
                            lowlink[v] = (std::min)(lowlink[v], lowlink[w]);
                        }
                        else if (on_stack[w])
                        {
                            lowlink[v] = (std::min)(lowlink[v], index_of[w]);
                        }
                    }
                }

                if (lowlink[v] == index_of[v])
                {
                    std::vector<std::string> scc;
                    std::string w;
                    do
                    {
                        w = stack.back();
                        stack.pop_back();
                        on_stack[w] = false;
                        scc.push_back(std::move(w));
                    } while (scc.back() != v);
                    result.push_back(std::move(scc));
                }
            }
        };

        context ctx;
        for (auto& [node, _] : graph)
        {
            if (ctx.index_of.find(node) == ctx.index_of.end())
            {
                ctx.strongconnect(node, graph);
            }
        }
        return std::move(ctx.result);
    }

    static int run(int const argc, char** argv)
    {
        int result{};
        writer w;

        try
        {
            auto start = get_start_time();

            reader args{ argc, argv, options };

            if (!args || args.exists("help") || args.exists("?"))
            {
                throw usage_exception{};
            }

            process_args(args);
            cache c{ get_files_to_cache(), [](TypeDef const& type) { return type.Flags().WindowsRuntime(); } };
            remove_foundation_types(c);
            build_filters(c);
            settings.base = settings.base || (!settings.component && settings.projection_filter.empty());
            build_fastabi_cache(c);

            if (settings.verbose)
            {
                {
                    char* path = argv[0];
#if defined(_WIN32) || defined(_WIN64)
                    char path_buf[32768];
                    DWORD path_size = GetModuleFileNameA(nullptr, path_buf, sizeof(path_buf));
                    if (path_size)
                    {
                        path_buf[sizeof(path_buf) - 1] = 0;
                        path = path_buf;
                    }
#endif
                    w.write(" tool:  %\n", path);
                }
                w.write(" ver:   %\n", CPPWINRT_VERSION_STRING);

                for (auto&& file : settings.input)
                {
                    w.write(" in:    %\n", file);
                }

                for (auto&& file : settings.reference)
                {
                    w.write(" ref:   %\n", file);
                }

                w.write(" out:   %\n", settings.output_folder);

                if (!settings.component_folder.empty())
                {
                    w.write(" cout:  %\n", settings.component_folder);
                }
            }

            w.flush_to_console();
            task_group group;
            group.synchronous(args.exists("synchronous"));

            // Dependency collection for per-namespace modules (v2)
            std::map<std::string, std::set<std::string>, std::less<>> ns_deps_map;
            std::set<std::string> projected_namespaces;
            std::mutex ns_deps_mutex;

            // First pass: determine which namespaces will be in the module.
            // This includes namespaces from this invocation AND those from other invocations
            // (e.g., platform namespaces when building a component). The module_filter
            // tells us which namespaces have modules across all invocations.
            if (settings.modules)
            {
                for (auto&& [ns, members] : c.namespaces())
                {
                    if (!has_projected_types(members))
                    {
                        continue;
                    }
                    if (settings.module_filter.empty() || settings.module_filter.includes(members))
                    {
                        projected_namespaces.insert(std::string(ns));
                    }
                }
            }

            for (auto&&[ns, members] : c.namespaces())
            {
                if (!has_projected_types(members) || !settings.projection_filter.includes(members))
                {
                    continue;
                }

                group.add([&, &ns = ns, &members = members]
                {
                    bool in_module = projected_namespaces.count(std::string(ns)) > 0;
                    std::set<std::string> ns_deps;
                    auto* deps_ptr = (settings.modules && in_module) ? &ns_deps : nullptr;

                    write_namespace_0_h(ns, members, deps_ptr);
                    write_namespace_1_h(ns, members, deps_ptr);
                    write_namespace_2_h(ns, members, deps_ptr);
                    write_namespace_h(c, ns, members, deps_ptr);

                    if (settings.modules && in_module)
                    {
                        std::lock_guard lock(ns_deps_mutex);
                        ns_deps_map[std::string(ns)] = std::move(ns_deps);
                    }
                });
            }

            if (settings.base)
            {
                write_base_h();
                write_macros_h();
            }

            if (settings.component)
            {
                std::vector<TypeDef> classes;

                for (auto&&[ns, members] : c.namespaces())
                {
                    for (auto&& type : members.classes)
                    {
                        if (settings.component_filter.includes(type))
                        {
                            classes.push_back(type);
                        }
                    }
                }

                if (!classes.empty())
                {
                    write_fast_forward_h(classes);
                    write_module_g_cpp(classes);

                    for (auto&& type : classes)
                    {
                        write_component_g_h(type);
                        write_component_g_cpp(type);
                        write_component_h(type);
                        write_component_cpp(type);
                    }
                }
            }

            group.get();

            // Generate per-namespace module interface files (.ixx)
            //
            // Each projected namespace gets its own C++20 named module (winrt.<Namespace>).
            // Namespaces that form dependency cycles are detected using Tarjan's SCC algorithm
            // and consolidated: one namespace "owns" the SCC module (containing all declarations),
            // while others get thin re-export stubs so 'import winrt.<ns>;' always works.
            //
            // Base infrastructure modules (winrt_base, winrt_numerics) are only generated
            // for platform projection builds (-base flag).
            if (settings.modules)
            {
                if (settings.base)
                {
                    write_numerics_ixx();
                    write_base_ixx();
                }

                // Tarjan's SCC algorithm for cyclic namespace dependencies
                auto sccs = find_sccs(ns_deps_map);

                for (auto& scc : sccs)
                {
                    if (scc.size() == 1)
                    {
                        // Standalone namespace module
                        auto& ns = scc[0];
                        write_namespace_ixx(ns, ns_deps_map[ns]);
                    }
                    else
                    {
                        // SCC: choose owner (alphabetically first), others re-export
                        std::sort(scc.begin(), scc.end());
                        auto& owner = scc[0];

                        // External deps = union of all SCC members' deps, minus SCC members themselves
                        std::set<std::string> external_deps;
                        std::set<std::string> scc_set(scc.begin(), scc.end());
                        for (auto& ns : scc)
                        {
                            for (auto& dep : ns_deps_map[ns])
                            {
                                if (!scc_set.count(dep))
                                {
                                    external_deps.insert(dep);
                                }
                            }
                        }

                        write_namespace_scc_owner_ixx(c, owner, scc, external_deps);

                        for (size_t i = 1; i < scc.size(); ++i)
                        {
                            write_namespace_reexport_ixx(scc[i], owner);
                        }
                    }
                }
            }

            if (settings.verbose)
            {
                w.write(" time:  %ms\n", get_elapsed_time(start));
            }
        }
        catch (usage_exception const&)
        {
            print_usage(w);
        }
        catch (std::exception const& e)
        {
            w.write("cppwinrt : error %\n", e.what());
            result = 1;
        }

        w.flush_to_console(result == 0);
        return result;
    }
}

int main(int const argc, char** argv)
{
    return cppwinrt::run(argc, argv);
}