#include "get_cmd.h"

USING_YOSYS_NAMESPACE

void GetCmd::help() {
    //   |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
    log("\n");
    log("   get_%ss [-quiet] [-filter filter_expression] "
        "<%s_selection> \n",
        TypeName().c_str(), TypeName().c_str());
    log("\n");
    log("Get matching %ss\n", TypeName().c_str());
    log("\n");
    log("Print the output to stdout too. This is useful when all Yosys "
        "is "
        "executed.\n");
    log("\n");
    log("    -filter\n");
    log("        Name and value of attribute to be taken into "
        "account.\n");
    log("        e.g. -filter { attr == \"true\" }\n");
    log("\n");
    log("    -quiet\n");
    log("        Don't print the result of the execution to stdout.\n");
    log("\n");
    log("    <selection_pattern>\n");
    log("        Selection of %s names. Default are all %ss in the "
        "design.\n",
        TypeName().c_str(), TypeName().c_str());
    log("\n");
}

void GetCmd::ExecuteSelection(RTLIL::Design* design, const CommandArgs& args) {
    std::vector<std::string> selection_args;
    // Add name of top module to selection string
    std::transform(args.selection_objects.begin(), args.selection_objects.end(),
                   std::back_inserter(selection_args),
                   [&](const std::string& obj) {
	               return RTLIL::unescape_id(design->top_module()->name) +
	                      "/" + SelectionType() + ":" + obj;
                   });
    extra_args(selection_args, 0, design);
    if (design->selected_modules().empty()) {
	if (!args.is_quiet) {
	    log_warning("Specified %s not found in design\n",
	                TypeName().c_str());
	}
    }
}

void GetCmd::PackToTcl(const SelectionObjects& objects) {
    Tcl_Obj* tcl_result;
    if (objects.size() == 1) {
	tcl_result = Tcl_NewStringObj(objects.at(0).c_str(), -1);
    } else {
	tcl_result = Tcl_NewListObj(0, NULL);
	for (const auto& object : objects) {
	    Tcl_Obj* value_obj = Tcl_NewStringObj(object.c_str(), -1);
	    Tcl_ListObjAppendElement(yosys_get_tcl_interp(), tcl_result,
	                             value_obj);
	}
    }
    Tcl_SetObjResult(yosys_get_tcl_interp(), tcl_result);
}

GetCmd::CommandArgs GetCmd::ParseCommand(const std::vector<std::string>& args) {
    CommandArgs parsed_args{.filters = Filters(),
                            .is_quiet = false,
                            .selection_objects = SelectionObjects()};
    size_t argidx(0);
    for (argidx = 1; argidx < args.size(); argidx++) {
	std::string arg = args[argidx];
	if (arg == "-quiet") {
	    parsed_args.is_quiet = true;
	    continue;
	}

	if (arg == "-filter" and argidx + 1 < args.size()) {
	    std::string filter_arg = args[++argidx];

	    // Remove spaces
	    filter_arg.erase(
	        std::remove_if(filter_arg.begin(), filter_arg.end(), isspace),
	        filter_arg.end());

	    // Parse filters
	    // TODO Add support for multiple condition expression
	    // Currently only a single == is supported
	    std::regex filter_attr_regex("(\\w+\\s?==\\s?\\w+)([(||)(&&)]*)");
	    std::regex_token_iterator<std::string::iterator> regex_end;
	    std::regex_token_iterator<std::string::iterator> matches(
	        filter_arg.begin(), filter_arg.end(), filter_attr_regex, 1);
	    if (matches == regex_end) {
		log_warning(
		    "Currently -filter switch supports only a single "
		    "'equal(==)' condition expression, the rest will be "
		    "ignored\n");
	    }

	    while (matches != regex_end) {
		std::string filter(*matches++);
		auto separator = filter.find("==");
		if (separator == std::string::npos) {
		    log_cmd_error("Incorrect filter expression: %s\n",
		                  args[argidx].c_str());
		}
		parsed_args.filters.emplace_back(filter.substr(0, separator),
		                                 filter.substr(separator + 2));
	    }
	    if (parsed_args.filters.size() > 1) {
		log_warning(
		    "Currently -filter switch supports only a single "
		    "'equal(==)' condition expression, the rest will be "
		    "ignored\n");
	    }
	    continue;
	}

	if (arg.size() > 0 and arg[0] == '-') {
	    log_cmd_error("Unknown option %s.\n", arg.c_str());
	}

	break;
    }
    std::copy(args.begin() + argidx, args.end(),
              std::back_inserter(parsed_args.selection_objects));
    return parsed_args;
}

void GetCmd::execute(std::vector<std::string> args, RTLIL::Design* design) {
    if (design->top_module() == nullptr) {
	log_cmd_error("No top module detected\n");
    }

    CommandArgs parsed_args(ParseCommand(args));
    ExecuteSelection(design, parsed_args);
    PackToTcl(ExtractSelection(design, parsed_args));
}