#ifdef DEBUG_DIAGNOSTICS
void mg_report_random_maps(FILE *outf, const level_id &place);

#endif

///////////////////////////////////////////////////////////////////////////
// Debugging code
#ifdef DEBUG_DIAGNOSTICS
typedef std::pair<std::string, int> weighted_map_name;
typedef std::vector<weighted_map_name> weighted_map_names;
static weighted_map_names mg_find_random_vaults(
    const level_id &place, bool wantmini)
{
    weighted_map_names wms;
    
    if (!place.is_valid())
        return (wms);
    for (unsigned i = 0, size = vdefs.size(); i < size; ++i)
    {
        if (vdefs[i].is_minivault() == wantmini
            && !vdefs[i].place.is_valid()
            && vdefs[i].is_usable_in(place)
            // Some tagged levels cannot be selected by depth. This is
            // the only thing preventing Pandemonium demon vaults from
            // showing up in the main dungeon.
            && !vdefs[i].has_tag_suffix("entry")
            && !vdefs[i].has_tag("pan")
            && !vdefs[i].has_tag("unrand")
            && !vdefs[i].has_tag("bazaar"))        
        {
            wms.push_back(
                weighted_map_name( vdefs[i].name, vdefs[i].chance ) );
        }
    }
    return (wms);    
}
static void mg_report_random_vaults(
    FILE *outf, const level_id &place, bool wantmini)
{
    weighted_map_names wms = mg_find_random_vaults(place, wantmini);
    int weightsum = 0;
    for (int i = 0, size = wms.size(); i < size; ++i)
        weightsum += wms[i].second;
    std::string line;
    for (int i = 0, size = wms.size(); i < size; ++i)
    {
        std::string curr =
            make_stringf("%s (%.2f%%)",
                         wms[i].first.c_str(),
                         100.0 * wms[i].second / weightsum);
        if (i < size - 1)
            curr += ", ";
        if (line.length() + curr.length() > 80u)
        {
            fprintf(outf, "%s\n", line.c_str());
            line.clear();
        }
        line += curr;
    }
    if (!line.empty())
        fprintf(outf, "%s\n", line.c_str());
}
void mg_report_random_maps(FILE *outf, const level_id &place)
{
    fprintf(outf, "---------------- Mini\n");
    mg_report_random_vaults(outf, place, true);
    fprintf(outf, "------------- Regular\n");
    mg_report_random_vaults(outf, place, false);
}
#endif

    mesclr();
    mprf("On %s (%d); %d g, %d fail, %d err%s, %d uniq, "
         "%d try, %d (%.2lf%%) vetos",
         level_id::current().describe().c_str(), niters,
         mg_levels_tried, mg_levels_failed, mapgen_errors.size(),
         mapgen_last_error.empty()? ""
         : (" (" + mapgen_last_error + ")").c_str(),
         mapgen_use_count.size(),
         mg_build_attempts, mg_vetoes,
         mg_build_attempts? mg_vetoes * 100.0 / mg_build_attempts : 0.0);

    if (niters > 1)
    {
        mesclr();
        mprf("On %s (%d); %d g, %d fail, %d err%s, %d uniq, "
             "%d try, %d (%.2lf%%) vetos",
             level_id::current().describe().c_str(), niters,
             mg_levels_tried, mg_levels_failed, mapgen_errors.size(),
             mapgen_last_error.empty()? ""
             : (" (" + mapgen_last_error + ")").c_str(),
             mapgen_use_count.size(),
             mg_build_attempts, mg_vetoes,
             mg_build_attempts? mg_vetoes * 100.0 / mg_build_attempts : 0.0);
    }

        you.uniq_map_tags.clear();
        you.uniq_map_names.clear();

static void mg_build_levels(int niters)

static std::vector<level_id> mg_dungeon_places()

    mesclr();
    mprf("Generating dungeon map stats");

    std::vector<level_id> places;

        {
            you.your_level = absdungeon_depth(branch, depth);
            you.where_are_you = branch;
            you.level_type = LEVEL_DUNGEON;

            places.push_back( level_id(branch, depth) );
    }

            int iters = niters;
            if (branch == BRANCH_MAIN_DUNGEON && depth == 1)
                iters *= 10;
            if (!mg_do_build_level(iters))
                return;
        }

    places.push_back(LEVEL_ABYSS);
    places.push_back(LEVEL_LABYRINTH);
    places.push_back(LEVEL_PANDEMONIUM);
    places.push_back(LEVEL_PORTAL_VAULT);
    return (places);
}
static void mg_build_dungeon()
{
    const std::vector<level_id> places = mg_dungeon_places();
    for (int i = 0, size = places.size(); i < size; ++i)
    {
        const level_id &lid = places[i];
        you.your_level = absdungeon_depth(lid.branch, lid.depth);
        you.where_are_you = lid.branch;
        you.level_type = lid.level_type;
        if (you.level_type == LEVEL_PORTAL_VAULT)
            you.level_type_name = "bazaar";
        if (!mg_do_build_level(1))
            return;

}

    you.level_type = LEVEL_ABYSS;
    if (!mg_do_build_level(niters))
        return;
    you.level_type = LEVEL_LABYRINTH;
    if (!mg_do_build_level(niters))
        return;
    you.level_type = LEVEL_PANDEMONIUM;
    if (!mg_do_build_level(niters))
        return;
    you.level_type = LEVEL_PORTAL_VAULT;
    you.level_type_name = "bazaar";
    if (!mg_do_build_level(niters))
        return;

static void mg_build_levels(int niters)
{
    mesclr();
    mprf("Generating dungeon map stats");
    for (int i = 0; i < niters; ++i)
    {
        mesclr();
        mprf("On %d of %d; %d g, %d fail, %d err%s, %d uniq, "
             "%d try, %d (%.2lf%%) vetos",
             i, niters,
             mg_levels_tried, mg_levels_failed, mapgen_errors.size(),
             mapgen_last_error.empty()? ""
             : (" (" + mapgen_last_error + ")").c_str(),
             mapgen_use_count.size(),
             mg_build_attempts, mg_vetoes,
             mg_build_attempts? mg_vetoes * 100.0 / mg_build_attempts : 0.0);
        
        you.uniq_map_tags.clear();
        you.uniq_map_names.clear();
        mg_build_dungeon();
    }

}
static void mapgen_report_avaiable_random_vaults(FILE *outf)
{
    you.uniq_map_tags.clear();
    you.uniq_map_names.clear();
    
    const std::vector<level_id> places = mg_dungeon_places();
    fprintf(outf, "\n\nRandom vaults available by dungeon level:\n");
    for (std::vector<level_id>::const_iterator i = places.begin();
         i != places.end(); ++i)
    {
        fprintf(outf, "\n%s -------------\n", i->describe().c_str());
        mg_report_random_maps(outf, *i);
        fprintf(outf, "---------------------------------\n");
    }

    mapgen_report_avaiable_random_vaults(outf);

MAP
x
ENDMAP
##############################################################################
# Dummy probability balancer vault for non-dungeon branches.
#
NAME: dummy_balancer_other
DEPTH: 1-, !D
# Vaults tagged "dummy" are no-ops when the dungeon builder is looking for maps
# by depth.
TAGS: dummy
ORIENT: float
CHANCE: 60