std::string debug_to_string() const;

std::string map_lua_marker::debug_to_string() const
{
    lua_stack_cleaner cln(dlua);
    if (!get_table())
        return ("Unable to get table for lua marker.");

    if (!dlua.callfn("table_to_string", 1, 1))
        return make_stringf("error (table_to_string): %s",
                            dlua.error.c_str());
    std::string result;
    if (lua_isstring(dlua, -1))
        result = lua_tostring(dlua, -1);
    else
        result = "table_to_string() returned nothing";
    return (result);
}

#include "mapmark.h"

}
static void _debug_marker_scan()
{
    std::vector<map_marker*> markers = env.markers.get_all();
    for (unsigned int i = 0; i < markers.size(); i++)
    {
        map_marker* marker = markers[i];
        if (marker == NULL)
        {
            mprf(MSGCH_ERROR, "Marker #%d is NULL", i);
            continue;
        }
        map_marker_type type = marker->get_type();
        if (type < MAT_FEATURE || type >= NUM_MAP_MARKER_TYPES)
            mprf(MSGCH_ERROR, "Makrer #%d at (%d, %d) has invalid type %d",
                 i, marker->pos.x, marker->pos.y, (int) type);
        if (!in_bounds(marker->pos))
        {
            mprf(MSGCH_ERROR, "Marker #%d, type %d at (%d, %d) out of bounds",
                 i, (int) type, marker->pos.x, marker->pos.y);
            continue;
        }
        bool found = false;
        std::vector<map_marker*> at_pos
            = env.markers.get_markers_at(marker->pos);
        for (unsigned int j = 0; j < at_pos.size(); j++)
        {
            map_marker* tmp = at_pos[i];
            if (tmp == NULL)
                continue;
            if (tmp == marker)
            {
                found = true;
                break;
            }
        }
        if (!found)
            mprf(MSGCH_ERROR, "Marker #%d, type %d at (%d, %d) unlinked",
                 i, (int) type, marker->pos.x, marker->pos.y);
    }
    for (int x = MAPGEN_BORDER; x < (GXM - MAPGEN_BORDER - 1); x++)
        for (int y = MAPGEN_BORDER; y < (GYM - MAPGEN_BORDER - 1); y++)
        {
            coord_def pos(x, y);
            std::vector<map_marker*> at_pos
                = env.markers.get_markers_at(pos);
            for (unsigned int i = 0; i < at_pos.size(); i++)
            {
                map_marker *marker = at_pos[i];
                if (marker == NULL)
                {
                    mprf(MSGCH_ERROR, "Marker #%d at (%d, %d) NULL",
                         i, x, y);
                    continue;
                }
                if (marker->pos != pos)
                {
                    mprf(MSGCH_ERROR, "Marker #%d, type %d at (%d, %d) "
                                      "thinks it's at (%d, %d)",
                         i, (int) marker->get_type(), x, y,
                         marker->pos.x, marker->pos.y);
                    if (!in_bounds(marker->pos))
                        mpr("Further, it thinks it's out of bounds.",
                            MSGCH_ERROR);
                }
            }
        }
} // _debug_marker_scan()
static void _debug_dump_markers()
{
    std::vector<map_marker*> markers = env.markers.get_all();
    for (unsigned int i = 0; i < markers.size(); i++)
    {
        map_marker* marker = markers[i];
        if (marker == NULL || marker->get_type() == MAT_LUA_MARKER)
            continue;
        mprf(MSGCH_DIAGNOSTICS, "Marker %d at (%d, %d): %s",
             i, marker->pos.x, marker->pos.y,
             marker->debug_describe().c_str());
    }
} // _debug_dump_markers()
static void _debug_dump_lua_markers()
{
    std::vector<map_marker*> markers = env.markers.get_all();
    for (unsigned int i = 0; i < markers.size(); i++)
    {
        map_marker* marker = markers[i];
        if (marker == NULL || marker->get_type() != MAT_LUA_MARKER)
            continue;
        map_lua_marker* lua_marker = dynamic_cast<map_lua_marker*>(marker);
        std::string result = lua_marker->debug_to_string();
        if (result.size() > 0 && result[result.size() - 1] == '\n')
            result = result.substr(0, result.size() - 1);
        mprf(MSGCH_DIAGNOSTICS, "Lua marker %d at (%d, %d):",
             i, marker->pos.x, marker->pos.y);
        mprf(MSGCH_DIAGNOSTICS, "{{{{");
        mprf(MSGCH_DIAGNOSTICS, result.c_str());
        mprf(MSGCH_DIAGNOSTICS, "}}}}");
    }

static void _debug_dump_lua_persist()
{
    lua_stack_cleaner cln(dlua);
    std::string result;
    if (!dlua.callfn("persist_to_string", 0, 1))
        result = make_stringf("error (persist_to_string): %s",
                              dlua.error.c_str());
    else if (lua_isstring(dlua, -1))
        result = lua_tostring(dlua, -1);
    else
        result = "persist_to_string() returned nothing";
    mprf(MSGCH_DIAGNOSTICS, "%s", result.c_str());
}

    // Dumping information on marker inconsistancy is unlikely to crash,
    // as is dumping the descriptions of non-Lua markers.
    fprintf(file, "Markers:" EOL);
    fprintf(file, "<<<<<<<<<<<<<<<<<<<<<<" EOL);
    _debug_marker_scan();
    _debug_dump_markers();
    fprintf(file, ">>>>>>>>>>>>>>>>>>>>>>" EOL);

    // print those stacks will likely crash, so do this last.

    // print those stacks will likely crash, so do this after the others.

    // Lastly try to dump the Lua persistant data and the contents of the Lua
    // markers, since actually running Lua code has the greatest chance of
    // crashing.
    fprintf(file, "Lua persistant data:" EOL);
    fprintf(file, "<<<<<<<<<<<<<<<<<<<<<<" EOL);
    _debug_dump_lua_persist();
    fprintf(file, ">>>>>>>>>>>>>>>>>>>>>>" EOL EOL);
    fprintf(file, "Lua marker contents:" EOL);
    fprintf(file, "<<<<<<<<<<<<<<<<<<<<<<" EOL);
    _debug_dump_lua_markers();
    fprintf(file, ">>>>>>>>>>>>>>>>>>>>>>" EOL);

end

end
-- Turn contents of a table into a human readable string
function table_to_string(table, depth)
  depth = depth or 0
  local indent = string.rep(" ", depth * 4)
  local str = ""
  for key, value in pairs(table) do
    str = str .. indent .. key .. ": "
    if type(value) == "table" then
      str = str .. "\n" .. table_to_string(value, depth + 1)
    elseif type(value) == "function" then
      str = str .. "function"
    else
      str = str .. value
    end
    str = str .. "\n"
  end
  return str
end

end

end
-- Turn persistant data into a human readable string
function persist_to_string()
    return table_to_string(dgn.persist)
end