#include "xml-writer.hh"

#include "value-to-json.hh"

static void findJobs(EvalState & state, XMLWriter & doc,

static void findJobs(EvalState & state, JSONObject & top,

static void tryJobAlts(EvalState & state, XMLWriter & doc,

static void tryJobAlts(EvalState & state, JSONObject & top,

        findJobs(state, doc, argsLeft, v, attrPath);

        findJobs(state, top, argsLeft, v, attrPath);

        tryJobAlts(state, doc, argsLeft, attrPath, fun, next, last, actualArgs);

        tryJobAlts(state, top, argsLeft, attrPath, fun, next, last, actualArgs);

        tryJobAlts(state, doc, argsLeft2, attrPath, fun, next, last, actualArgs2);

        tryJobAlts(state, top, argsLeft2, attrPath, fun, next, last, actualArgs2);

static void findJobsWrapped(EvalState & state, XMLWriter & doc,

static void findJobsWrapped(EvalState & state, JSONObject & top,

            XMLAttrs xmlAttrs;

            xmlAttrs["jobName"] = attrPath;
            xmlAttrs["nixName"] = drv.name;
            xmlAttrs["system"] = drv.system;
            xmlAttrs["drvPath"] = drvPath = drv.queryDrvPath();
            xmlAttrs["description"] = drv.queryMetaString("description");
            xmlAttrs["longDescription"] = drv.queryMetaString("longDescription");
            xmlAttrs["license"] = queryMetaStrings(state, drv, "license");
            xmlAttrs["homepage"] = drv.queryMetaString("homepage");
            xmlAttrs["maintainers"] = queryMetaStrings(state, drv, "maintainers");
            xmlAttrs["schedulingPriority"] = int2String(drv.queryMetaInt("schedulingPriority", 100));
            xmlAttrs["timeout"] = int2String(drv.queryMetaInt("timeout", 36000));
            xmlAttrs["maxSilent"] = int2String(drv.queryMetaInt("maxSilent", 7200));

            top.attr(attrPath);
            JSONObject res(top.str);
            res.attr("nixName", drv.name);
            res.attr("system", drv.system);
            res.attr("drvPath", drvPath = drv.queryDrvPath());
            res.attr("description", drv.queryMetaString("description"));
            res.attr("longDescription", drv.queryMetaString("longDescription"));
            res.attr("license", queryMetaStrings(state, drv, "license"));
            res.attr("homepage", drv.queryMetaString("homepage"));
            res.attr("maintainers", queryMetaStrings(state, drv, "maintainers"));
            res.attr("schedulingPriority", drv.queryMetaInt("schedulingPriority", 100));
            res.attr("timeout", drv.queryMetaInt("timeout", 36000));
            res.attr("maxSilent", drv.queryMetaInt("maxSilent", 7200));

                xmlAttrs["constituents"] = concatStringsSep(" ", drvs);

                res.attr("constituents", concatStringsSep(" ", drvs));

            XMLOpenElement _(doc, "job", xmlAttrs);
            foreach (DrvInfo::Outputs::iterator, j, outputs) {
                XMLAttrs attrs2;
                attrs2["name"] = j->first;
                attrs2["path"] = j->second;
                doc.writeEmptyElement("output", attrs2);
            }

            res.attr("outputs");
            JSONObject res2(res.str);
            for (auto & j : outputs)
                res2.attr(j.first, j.second);

                    findJobs(state, doc, argsLeft, *i->value,

                    findJobs(state, top, argsLeft, *i->value,

        tryJobAlts(state, doc, argsLeft, attrPath, v,

        tryJobAlts(state, top, argsLeft, attrPath, v,

static void findJobs(EvalState & state, XMLWriter & doc,

static void findJobs(EvalState & state, JSONObject & top,

        findJobsWrapped(state, doc, argsLeft, v, attrPath);

        findJobsWrapped(state, top, argsLeft, v, attrPath);

        XMLAttrs xmlAttrs;
        xmlAttrs["location"] = attrPath;
        xmlAttrs["msg"] = e.msg();
        XMLOpenElement _(doc, "error", xmlAttrs);

        top.attr(attrPath);
        JSONObject res(top.str);
        res.attr("error", e.msg());
        top.str << "\n";

        XMLWriter doc(true, std::cout);
        XMLOpenElement root(doc, "jobs");
        findJobs(state, doc, autoArgs, v, "");

        JSONObject json(std::cout);
        findJobs(state, json, autoArgs, v, "");

use XML::Simple;

use JSON;

    (my $res, my $jobsXml, my $stderr) = captureStdoutStderr(10800,

    (my $res, my $jobsJSON, my $stderr) = captureStdoutStderr(10800,

    if ($res) {
        die "$evaluator returned " . ($res & 127 ? "signal $res" : "exit code " . ($res >> 8))
            . ":\n" . ($stderr ? $stderr : "(no output)\n");
    }

    die "$evaluator returned " . ($res & 127 ? "signal $res" : "exit code " . ($res >> 8))
        . ":\n" . ($stderr ? $stderr : "(no output)\n")
        if $res;

    my $jobs = XMLin(
        $jobsXml,
        ForceArray => ['error', 'job', 'arg', 'output'],
        KeyAttr => { output => "+name" },
        SuppressEmpty => '')
        or die "cannot parse XML output";
    my %jobNames;
    my $errors;
    my @filteredJobs = ();
    foreach my $job (@{$jobs->{job}}) {
        # Ensure that there is only one job with the given
        # name. FIXME: this check will become unnecessary after we
        # remove support for multiple values per jobset input.
        if (defined $jobNames{$job->{jobName}}) {
            $errors .= "error: there are multiple jobs named ‘$job->{jobName}’\n\n";
            next;
        }
        $jobNames{$job->{jobName}} = 1;
        push @filteredJobs, $job;
    }
    $jobs->{job} = \@filteredJobs;
    # Handle utf-8 characters in error messages. No idea why this works.
    utf8::decode($_->{msg}) foreach @{$jobs->{error}};
    return ($jobs, $nixExprInput, $errors);

    return (decode_json($jobsJSON), $nixExprInput);

    my @outputNames = sort keys %{$buildInfo->{output}};

    my @outputNames = sort keys %{$buildInfo->{outputs}};

    my $firstOutputPath = $buildInfo->{output}->{$firstOutputName}->{path};

    my $firstOutputPath = $buildInfo->{outputs}->{$firstOutputName};

    my $priority = 100;
    $priority = int($buildInfo->{schedulingPriority})
        if $buildInfo->{schedulingPriority} =~ /^\d+$/;

            my $path = $buildInfo->{output}->{$name}->{path};

            my $path = $buildInfo->{outputs}->{$name};

            , priority => $priority

            , priority => $buildInfo->{schedulingPriority}

        $build->buildoutputs->create({ name => $_, path => $buildInfo->{output}->{$_}->{path} })

        $build->buildoutputs->create({ name => $_, path => $buildInfo->{outputs}->{$_} })

    my ($jobs, $nixExprInput, $msg) = evalJobs($inputInfo, $exprType, $jobset->nixexprinput, $jobset->nixexprpath);

    my ($jobs, $nixExprInput) = evalJobs($inputInfo, $exprType, $jobset->nixexprinput, $jobset->nixexprpath);

    $jobs->{$_}->{jobName} = $_ for keys %{$jobs};

        foreach my $job (permute @{$jobs->{job}}) {
            next if $job->{jobName} eq "";

        foreach my $job (permute(values %{$jobs})) {
            next if defined $job->{error};

    foreach my $error (@{$jobs->{error}}) {

    my $msg = "";
    foreach my $job (values %{$jobs}) {
        next unless defined $job->{error};

            ($error->{location} ne "" ? "in job ‘$error->{location}’" : "at top-level") .
            ":\n" . $error->{msg} . "\n\n";

            ($job->{jobName} ne "" ? "in job ‘$job->{jobName}’" : "at top-level") .
            ":\n" . $job->{error} . "\n\n";