int _main()

in include/poac/subcmd/install.hpp [212:307]
82 lines of code
23 McCabe index (conditional complexity)

        int _main(VS&& argv) {
            namespace fs = boost::filesystem;
            namespace exception = core::exception;
            namespace path = io::file::path;
            namespace yaml = io::file::yaml;
            namespace cli = io::cli;
            namespace resolver = core::resolver;


            fs::create_directories(path::poac_cache_dir);
            auto node = yaml::load_config();
            std::string timestamp = yaml::get_timestamp();
            const bool quite = util::argparse::use_rm(argv, "-q", "--quite");
            const bool verbose = util::argparse::use_rm(argv, "-v", "--verbose") && !quite;

            // load lock file
            resolver::Resolved resolved_deps{};
            bool load_lock = false;
            if (argv.empty()) { // 引数からの指定の時，lockファイルを無視する
                if (const auto locked_deps = core::lock::load(timestamp)) {
                    resolved_deps = *locked_deps;
                    load_lock = true;
                }
            }

            // resolve package
            if (!quite) {
                cli::echo(cli::to_status("Resolving packages..."));
            }
            resolver::Deps deps;
            if (!argv.empty()) {
                for (const auto& v : argv) {
                    deps.push_back(parse_arg_package(v));
                }
            }
            if (!load_lock) {
                if (const auto deps_node = yaml::get<std::map<std::string, YAML::Node>>(node, "deps")) {
                    const auto resolved_packages = resolve_packages(*deps_node);
                    deps.insert(deps.end(), resolved_packages.begin(), resolved_packages.end());
                }
                else if (argv.empty()) { // 引数から指定しておらず(poac install)，poac.ymlにdeps keyが存在しない
                    throw exception::error(
                            "Required key `deps` does not exist in poac.yml.\n"
                            "Please refer to https://docs.poac.io");
                }
            }

            // resolve dependency
            if (!quite) {
                cli::echo(cli::to_status("Resolving dependencies..."));
            }
            if (!load_lock) {
                resolved_deps = resolver::resolve(deps);
            }

            // download packages
            if (!quite) {
                cli::echo(cli::to_status("Fetching..."));
                cli::echo();
            }
            fs::create_directories(path::current_deps_dir);
            fetch_packages(resolved_deps.backtracked, quite, verbose);
            if (!quite) {
                cli::echo();
                cli::echo(cli::status_done());
            }

            // Rewrite poac.yml
            bool fix_yml = false;
            for (const auto& d : deps) {
                if (d.interval == "latest") {
                    node["deps"][d.name] = convert_to_interval(resolved_deps.backtracked[d.name].version);
                    fix_yml = true;
                }
            }
            if (!argv.empty()) {
                fix_yml = true;
                for (const auto& d : deps) {
                    if (d.interval != "latest") {
                        node["deps"][d.name] = d.interval;
                    }
                }
            }
            if (fix_yml) {
                if (std::ofstream ofs("poac.yml"); ofs) {
                    ofs << node;
                }
                timestamp = yaml::get_timestamp();
            }

            if (!load_lock) {
                create_lock_file(timestamp, resolved_deps.activated);
            }

            return EXIT_SUCCESS;
        }