metamap.lic

=begin
  Metamap is a tool for setting and updating map metadata.  This metadata is used by xnarost (and possibly other tools)
  to assign friendly names and categories to individual maps.

  For each map, there should be one (and preferably only one) room with the following tags:

  meta:mapname:NAME
  REQUIRED.  Specifies the 'long' name of the map, as shown in XNarost's list of all maps.

  meta:mapshortname:NAME
  OPTIONAL.  Specifies the 'short' name of the map, as shown in XNarost's list of maps within a single category.
  If omitted, this is the same as the longer name above.

  meta:mapcategory:CATEGORY  or meta:mapcategory:CATEGORY:SHORTNAME
  OPTIONAL.  Specifies which category this map belongs under and (optionally) its name within that category.
  Maps without this tag will not be categorized.
  This tag may be specified multiple times to specify multiple categories.

  author: LostRanger (thisgenericname@gmail.com)

	game: any
	tags: core, movement

  version: 0.1 (2019-08-14)

  changelog:
    version 0.1
     * Initial release
=end


module MetaMapScript
    class Metadata
        attr_reader :name, :shortname, :categories, :id
        attr_reader :rooms, :metadata_rooms

        @@cache = {}

        def Metadata.image_to_id(image)
            if image =~ /^(.+)\.[^.]*$/
                image = $1
            end

            if image =~ /^(.+)-\d+$/
                return $1
            end
            return image
        end

        def Metadata.unload
            @@cache.clear
        end

        def Metadata.load_all
            unload

            Room.list.each do |room|
                next unless room.image
                id = image_to_id(room.image)
                (@@cache[id] or self.new(id)).ingest_room(room)
            end
        end

        def Metadata.all
            Metadata.load_all
            return @@cache.values
        end

        def Metadata.sorted
            return all.sort_by{|x| x.id.downcase}
        end

        def Metadata.[](id)
            id = image_to_id(id)
            map = @@cache[id]
            return map if map

            Room.list.each do |room|
                next unless room.image
                next unless image_to_id(room.image) == id
                map ||= self.new(id)
                map.ingest_room(room)
            end

            return map
        end

        def initialize(id)
            @id = id
            @@cache[id] = self
            @primary_room = nil
            @rooms = []
            @metadata_rooms = Set.new
            @name = nil
            @shortname = nil
            @categories = {}
        end

        def ingest_room(room)
            @rooms << room
            return unless room.tags
            room.tags.each do |tag|
                if tag =~ /^meta:mapname:(.*)$/
                    @metadata_rooms << room
                    @name ||= $1
                elsif tag =~ /^meta:mapshortname:(.*)$/
                    @metadata_rooms << room
                    @shortname ||= $1
                elsif tag =~ /^meta:mapcategory:(.*?)(?::(.*))?$/
                    @metadata_rooms << room
                    unless @categories.include?($1)
                        @categories[$1] = $2
                    end
                end
            end
        end

        def primary_room
            return @primary_room if @primary_room

            tagged_rooms = {
                'town' => [],
                'voln' => [],
                'supernode' => [],
                'node' => [],
            }

            @rooms.each do |room|
                next unless room.tags
                room.tags.each do |tag|
                    t = tagged_rooms[tag]
                    next unless t
                    t << room
                end
            end

            best_untagged_room = nil

            tagged_rooms.each do |tag, rooms|
                next if rooms.length == 0
                room = rooms.find{|rm| rm.tags.find{|tag| tag =~ /^meta:map(?:name|shortname|category):/}}
                return @primary_room = room if room
                best_untagged_room ||= rooms[0]
            end

            @metadata_rooms.each do |room|
                return @primary_room = room
            end

            # return @primary_room = @metadata_rooms[0] if @metadata_rooms.length > 0
            return @primary_room = best_untagged_room if best_untagged_room
            return @primary_room = @rooms[0]
        end

        def condense(target=nil)
            if target
                @primary_room = target
            else
                target = self.primary_room
            end

            return target if @metadata_rooms.length == 1 and @metadata_rooms.to_a[0] == target  # Nothing to condense.
            meta_tags = Set.new
            @metadata_rooms.each do |room|
                next unless room.tags
                new_tags = []
                room.tags.each do |tag|
                    if tag =~ /^meta:map(?:name|shortname|category):/
                        meta_tags << tag
                    else
                        new_tags << tag
                    end
                end
                if new_tags.length
                    room.tags = new_tags
                else
                    room.tags = nil
                end
            end

            target.tags ||= []
            target.tags += meta_tags.to_a
            @metadata_rooms = Set.new
            @metadata_rooms << target
            return target
        end

        def _set_name(prefix, value)
            tag = "#{prefix}#{value}" if value
            target = condense
            if target.tags
                target.tags.delete_if{|x| x.start_with?(prefix)}
                target.tags << tag if value
            else
                target.tags = tag if value
            end

            return value
        end

        def name=(v); @name = _set_name("meta:mapname:", v); end
        def shortname=(v); @shortname = _set_name("meta:mapshortname:", v); end

        def add_category(category, shortname=nil)
            target = condense
            prefix = "meta:mapcategory:#{category}"
            tag = prefix.dup
            tag += ":#{shortname}" if shortname

            if target.tags
                target.tags.delete_if{|x| x == prefix or x.start_with?("#{prefix}:")}
                target.tags << tag
            else
                target.tags = tag
            end

            return shortname
        end

        def del_category(category)
            target = condense
            prefix = "meta:mapcategory:#{category}"

            if target.tags
                target.tags.delete_if{|x| x == prefix or x.start_with?("#{prefix}:")}
            end
        end
    end


    VERSION = '0.1 (2019-08-14)'
    VERSION_INT = 1_000


    def self.send_formatted(msg, mono=true)
        if @stormfront
            msg = REXML::Text.new(msg, respect_whitespace: true).to_s
            msg.gsub!(/\*\*(.*?)\*\*/, '<preset id="whisper">\1</preset>')
            msg = "<output class=\"mono\" />\n#{msg}\n<output class=\"\" />" if mono
            puts msg
        else
            msg.gsub!('**', '')
            respond msg
        end
    end

    def self.send_help_formatted(msg)
        if @stormfront
            msg = REXML::Text.new(msg, respect_whitespace: true).to_s
            msg.gsub!(/\*\*(.*?)\*\*/, '<preset id="whisper">\1</preset>')
            msg.gsub!(/`(.*?)`/, '<preset id="speech">\1</preset>')
            msg.gsub!("#{name} help", "</preset><d cmd=\"#{name} help\">#{name} help</d><preset id=\"whisper\">")
            puts "<output class=\"mono\" />\n#{msg}\n<output class=\"\" />"
        else
            msg.gsub!('**', '')
            msg.gsub!('`', '')
            respond msg
        end
    end

    def self.show_changelog
        prev = GameSettings[:current_version] || 0

        changelog = {
            # 1_000 => [
            #     "Major version 0.1 changes:",
            #     '',
            #     "  * Initial release.",
            # ],
        }

        if prev != VERSION_INT
            msg = []
            msg << "<preset id='speech'>--------------------</preset>"
            msg << "<preset id='speech'>Welcome to #{$lich_char}#{@script.name}</preset> <preset id='whisper'>#{VERSION}</preset>"
            msg << ''
            changelog.each do |version, notes|
                if version > prev or version == VERSION_INT
                    msg << "<preset id='whisper'>#{notes[0]}</preset>"
                    msg += notes[1..-1]
                    msg << ''
                end
            end
            msg << '<output class="mono" />'
            msg << "For a more detailed changelog: <d>#{$lich_char}repo info #{@script.name}</d>."
            msg << "To enable automatic updates:   <d>#{$lich_char}repo set-updatable #{@script.name}</d>`."
            msg << "For details on new features:   <d>#{$lich_char}#{@script.name} help</d>"
            #msg << "                   or visit:   #{HELP_URL}"
            msg << "For more LostRanger scripts:   https://bit.ly/lostranger-scripts"
            msg << '<output class="" />'
            msg << ''
            msg << "This message will only be displayed once unless a new version is downloaded."
            msg << "<preset id='speech'>--------------------</preset>"
            send msg
            GameSettings[:current_version] = VERSION_INT
            sleep 1.5
        end
    end

    def self.send(what)
        if @stormfront
            return _respond(what)
        end

        unless what.is_a?(Array)
            what = [what]
        end

        return _respond what.map{|line|
            if line =~ /^\s*<\/?output[^>]*>$/
                nil
            else
                line = line.gsub(/<preset.*?>(.*?)<\/preset>/, "\\1")
                line.gsub!('<pushBold/>', monsterbold_start)
                line.gsub!('<popBold/>', monsterbold_end)
                line.gsub!(/<\/?d.*?>/, '')
                line
            end
        }.keep_if{|x| x}
    end

    def self.show_help
        name = "#{$lich_char}#{@script.name}"
        msg = []
        msg << "**This is #{@script.name} version #{VERSION}**"
        msg << "**Information:**"
        # msg << "     `#{name} reload`"
        # msg << "         Reload all map data to reflect any changes made."
        msg << "     `#{name} maps`"
        msg << "         List all known maps."
        msg << "     `#{name} cats`"
        msg << "         List all known categories."
        msg << "     `#{name} categories`"
        msg << "         List all known categories."
        msg << ""
        msg << "**Consistency Checks:**"
        msg << "     `#{name} check`"
        msg << "         Check metadata consistency for the current map."
        msg << "     `#{name} check` **MAPID**"
        msg << "         Check metadata consistency for the specified map ID."
        msg << "     `#{name} check` **ROOM#**"
        msg << "         Check metadata consistency for the map associated with the specified room#"
        msg << "     `#{name} check all`"
        msg << "         Check metadata consistency for ALL maps."
        msg << ""
        msg << "**Map Metadata Updates:**"
        msg << "     These commands all target the current room's map by default.  You can override this by preceding the command with @<ROOM#> or @<MAPID>"
        msg << "     e.g. `#{name} @288 name Wehnimer's Landing - Town Map`"
        msg << "     or   `#{name} @wl-wehnimers name Wehnimer's Landing - Town Map`"
        msg << ""
        msg << "     **NOTE: **Metadata updates will condense all meta tags for the map into a single room if they are not already."
        msg << ""
        msg << "     `#{name} name` **NAME**"
        msg << "         Set the name of the current map.  This is shown in the list of all maps."
        msg << "     `#{name} short` **SHORTNAME**"
        msg << "         Set the 'short name' of the current map.  This is shown within categorized lists.  You may use 'none' to remove an existing shortname."
        msg << "     `#{name} add` **CATEGORY**"
        msg << "         Adds this map to the CATEGORY category, using its default short name."
        msg << "     `#{name} add` **CATEGORY**`:`**SHORTNAME**"
        msg << "         Adds this map to the CATEGORY category, using the specified short name."
        msg << "     `#{name} remove` **CATEGORY**"
        msg << "         Removes this map from the CATEGORY category.  `remove` may be shortened to `rem` or `rm`"
        msg << "     `#{name} target` [**ROOM#**]"
        msg << "         Moves metadata for this map to the specified ROOM#, which must use this map.  If ROOM# is omitted, the current room is used."
        # msg << ""
        # msg << "**Categories:**"
        # msg << "     `#{name} rename` **OLD**`;`**NEW**"
        # msg << "         Rename the category named OLD to NEW."
        # msg << "     `#{name} merge` **OLD**`;`**NEW**"
        # msg << "         Merge contents of category OLD with NEW."
        # msg << "     `#{name} delete` **CATEGORY**"
        # msg << "         Delete category CATEGORY."

        return send_help_formatted(msg.join("\n"))
    end

    def self.get_map(what=nil)
        if what
            if what =~ /^\d+$/
                rm = Room[what]
                unless rm
                    echo "Room ##{what} does not exist."
                    exit
                end
                unless rm.image
                    echo "Room ##{what} has no map image."
                    exit
                end
                what = rm.image
            end
        else
            rm = Room.current
            unless rm.id
                echo "Current room does not appear to be in the map database."
                exit
            end
            unless rm.image
                echo "Current room ##{what} has no map image."
                exit
            end
            what = rm.image
        end

        result = Metadata[what]
        unless result
            echo "Map '#{what}' not found."
            exit
        end
        return result
    end

    def self.display_table(table, nil_as='-')
        widths = {}
        rightalign = {}

        table.each do |row|
            row.each do |k, v|
                widths[k] ||= k.length
                if v.nil?
                    v = nil_as
                elsif v.is_a?(Numeric)
                    row[k] = v = v.to_s
                    rightalign[k] = true
                end
                l = v.length
                widths[k] = l if widths[k] < l
            end
        end

        header = []
        separator = []
        widths.each do |k,v|
            if rightalign[k]
                header << k.rjust(v)
            else
                header << k.ljust(v)
            end
            separator << '-'*v
        end
        header = header.join(' | ')
        separator = separator.join('-|-')

        output = [header, separator]
        table.each do |row|
            output << (row.map{|k,v|
                w = widths[k]
                next v.rjust(w) if rightalign[k]
                next v.ljust(w)
            }.join(' | ').rstrip)
        end
        output << separator
        output << header
        respond output
    end

    def self.do_check(what)
        if what
            if what.downcase == 'all'
                @target_map = nil
            else
                @target_map = get_map(what)
            end
        else
            @target_map ||= get_map
        end

        if @target_map
            maps = [@target_map]
        else
            maps = Metadata.sorted
        end

        msg = []
        one = (maps.length == 1)
        maps.each do |map|
            prefix = "[#{map.id}]"

            msg << "#{prefix} rooms: #{map.rooms.length}; primary: #{map.primary_room.id or 'NONE'}" if one
            n = map.metadata_rooms.length
            if n == 0
                msg << "#{prefix} no metadata defined."
                next
            end
            if map.name.nil?
                msg << "#{prefix} map has no name."
            end
            if n == 2
                msg << "#{prefix} metadata is defined on multiple rooms: #{map.metadata_rooms.map(&:id).join(', ')}"
                msg << "#{prefix} target a single room using: #{$lich_char}#{@script.name} @#{map.id} target ROOM"
            elsif one
                msg << "#{prefix} metadata is defined on room: #{map.metadata_rooms.map(&:id).join(', ')}"
            end

            if one
                msg << "#{prefix} name: #{map.name}"
                msg << "#{prefix} shortname: #{map.shortname or '(undefined)'}"
                if map.categories.length == 0
                    msg << "#{prefix} has no defined categories!"
                else
                    categories = map.categories.map{|k, v|
                        next(k) unless v
                        next("#{k} (#{v})")
                    }.join('; ')
                    msg << "#{prefix} categories (and shortnames): #{categories}"
                end
            end

            names = Set.new
            name_count = 0
            shortnames = Set.new
            shortname_count = 0
            category_names = {}
            category_counts = {}

            map.metadata_rooms.each{|room|
                next unless room.tags
                room.tags.each{|x|
                    if x =~ /^meta:mapname:(.*)$/
                        names << $1
                        name_count += 1
                    elsif x =~ /^meta:mapshortname:(.*)$/
                        shortnames << $1
                        shortname_count += 1
                    elsif x =~ /^meta:mapcategory:(.*?)(?::(.*))?$/
                        category_names[$1] ||= Set.new
                        category_names[$1] << $2
                        category_counts[$1] ||= 0
                        category_counts[$1] += 1
                    end
                }
            }

            if name_count > 1
                msg << "#{prefix} name is declared #{name_count} times instead of just once."
                if names.length > 1
                    msg << "#{prefix} has conflicting name declarations: #{names.to_a.join('; ')}"
                end
                msg << "#{prefix} fix this using: #{$lich_char}#{@script.name} @#{map.id} name NEWNAME"
            end

            if shortname_count > 1
                msg << "#{prefix} shortname is declared #{shortname_count} times instead of just once."
                if shortnames.length > 1
                    msg << "#{prefix} has conflicting shortname declarations: #{shortnames.to_a.join('; ')}"
                end
                msg << "#{prefix} fix this using: #{$lich_char}#{@script.name} @#{map.id} shortname NEWNAME"
            end

            category_counts.each do |cat, count|
                next unless count > 1
                msg << "#{prefix} category '#{cat}' is mentioned #{count} times instead of just once."
                n = category_names[cat]
                if n.length > 1
                    msg << "#{prefix} has conflicting category '#{cat}' shortname declarations: #{n.to_a.map{|k| k or 'DEFAULT'}.join('; ')}"
                end
                msg << "#{prefix} fix this using: #{$lich_char}#{@script.name} @#{map.id} add CATEGORY"
                msg << "#{prefix} or using:       #{$lich_char}#{@script.name} @#{map.id} add CATEGORY:SHORTNAME"
            end
        end
        msg << "Total maps: #{maps.length}" unless one
        respond msg
    end

    def self.run(script)
        before_dying { Metadata.unload }
        @stormfront = !$fake_stormfront
        @script = script
        @script.want_downstream = false
        @script.want_downstream_xml = false

        @target_map = nil
        cmdline = script.vars[0].strip || ''
        unless cmdline =~ /^(?:@(?:(\d+)|([^\s]+))\s+?)?(?!@)(.+)/
            echo "For help, see #{$lich_char}#{script.name} help"
            exit
        end
        cmdline = $3.strip
        if $1
            @target_map = get_map($1)
        elsif $2
            @target_map = get_map($2)
        else
            @target_map = nil
        end

        if cmdline =~ /^help$/i
            show_help
            exit
        elsif cmdline =~ /^reload$/i
            Metadata.unload
            echo "Metadata unloaded."
            exit
        elsif cmdline =~ /^maps$/i
            table = []
            Metadata.sorted.each do |map|
                table << {
                    'KEY' => map.id,
                    'NAME' => map.name || '(none)',
                    'SHORTNAME' => map.shortname || '(none)',
                    'PRIMARY' => (map.primary_room.id) || '???',
                    '#RMS' => map.rooms.length,
                    '#META' => map.metadata_rooms.length,
                }
            end

            display_table(table)
            exit
        elsif cmdline =~ /^cats$|^categories$/i
            categories = {}
            Metadata.all.each do |map|
                map.categories.each{|cat, _| categories[cat] ||= 0; categories[cat] += 1}
            end

            table = categories.map{|k,v| {'#MAPS' => v, 'NAME' => k}}
            table.sort_by!{|row| row['NAME']}
            display_table(table)
            exit
        elsif cmdline =~ /^name(?:\s+(.*))?$/i
            @target_map ||= get_map
            if $1
                @target_map.name = $1
                echo "Map #{@target_map.id} name is now '#{$1}'"
            elsif @target_map.name
                echo "Map #{@target_map.id} name is #{@target_map.name}."
            else
                echo "Map #{@target_map.id} has no name."
            end
        elsif cmdline =~ /^short(?:name)?(?:\s+(.*))?$/i
            @target_map ||= get_map
            if $1
                if $1.downcase == 'none'
                    @target_map.shortname = nil
                    echo "Map #{@target_map.id} shortname deleted."
                else
                    @target_map.shortname = $1
                    echo "Map #{@target_map.id} shortname is now '#{$1}'"
                end
            elsif @target_map.shortname
                echo "Map #{@target_map.id} shortname is #{@target_map.shortname}."
            else
                echo "Map #{@target_map.id} has no shortname."
            end
        elsif cmdline =~ /^add\s+(.+?)(?::(.*))?$/i
            @target_map ||= get_map
            category = $1
            shortname = $2
            shortname = nil if shortname == ''
            # Ensure that the category exists.
            unless Metadata.all.find{|map| map.categories.include?($1)}
                echo "Category '#{$1}' does not yet exist -- i.e. it is not referenced by any other maps."
                echo "To continue anyways and add this category, unpause this script.  Otherwise, kill this script."
                pause_script
            end
            @target_map.add_category(category, shortname)
            if shortname
                echo "Map #{@target_map.id} added to category '#{category}' using shortname '#{shortname}'."
            else
                echo "Map #{@target_map.id} added to category '#{category}' using its default shortname."
            end
            exit
        elsif cmdline =~ /^(?:rm|rem|remove)\s+(.+?)(?::(.*))?$/i
            @target_map ||= get_map
            category = $1
            if @target_map.categories.include?(category)
                @target_map.del_category(category)
                echo "Map #{@target_map.id} removed from category '#{category}'."
            else
                echo "Map #{@target_map.id} is not in category '#{category}'."
            end
            exit
        elsif cmdline =~ /^target(?:\s+(\d+))?$/i
            @target_map ||= get_map
            if $1
                roomid = $1.to_i
            else
                roomid = Room.current.id
                unless roomid
                    echo "The current room is not in the map database."
                    exit
                end
            end
            unless @target_map.rooms.find{|x| x.id == roomid}
                echo "Room ##{roomid} is not on the #{@target_map.id} map."
                exit
            end
            @target_map.condense(Room[roomid])
            echo "Metadata for map #{@target_map.id} moved to room ##{roomid}."
            do_check(@target_map.id)
        elsif cmdline =~ /^check(?:\s+(.+))?$/i
            do_check($1)
        end

        # echo @target_map.inspect
    end
end


MetaMapScript.run(script)