tag_parser_bot:
    type: world
    debug: false
    samples:
        link: (UNSET)
        sample_bool: true
        sample_0: 0
        sample_1: 1
        sample_10: 10
        sample_0p5: 0.5
        sample_text: Hello, world!
        help: try typing 'help' to the bot!
    script_paths:
        stop_bot:
        - if <server.has_flag[tag_parser_bot_running]>:
            - discord id:tag_parser disconnect
            - flag server tag_parser_bot_running:!
        start_bot:
        - inject locally script_paths.stop_bot
        - yaml load:data/tag_parser.yml id:tag_parser_temp
        - if !<yaml.list.contains[tag_parser_temp]>:
            - debug error "Load failed."
            - stop
        - flag server tag_parser_logpath:<yaml[tag_parser_temp].read[bot.discord.log_path]>
        - flag server tag_parser_validchannels:!
        - flag server tag_parser_validchannels:|:<yaml[tag_parser_temp].read[bot.discord.valid_channels]>
        - flag server tag_parser_barredchannels:!
        - flag server tag_parser_barredchannels:|:<yaml[tag_parser_temp].read[bot.discord.barred_channels]>
        - flag server tag_parser_barredchannelmessages:!
        - flag server tag_parser_barredchannelmessages:|:<yaml[tag_parser_temp].read[bot.discord.barred_channel_messages]>
        - flag server tag_parser_link:<yaml[tag_parser_temp].read[script.link]>
        - define samples <script.data_key[samples].with[link].as[<server.flag[tag_parser_link]>].with[version].as[<server.version>].with[denizen_version].as[<server.denizen_version>]>
        - flag server tag_parser_samples:<[samples]>
        - discord id:tag_parser connect code:<yaml[tag_parser_temp].read[bot.discord.token]>
        - yaml unload id:tag_parser_temp
        - flag server tag_parser_bot_running
        process_tag:
        - log "<util.time_now.format> [<[name]>] in [<[origin]>] wants to process tag <[tag]>" file:<server.flag[tag_parser_logpath]>
        - flag server tag_parser_result_temp:!
        - ~run tag_run_task def:<[tag]>
        - define result <server.flag[tag_parser_result_temp]||FAILED=FLAG_MISSING;>
        - define recorded <server.flag[tag_parser_record_temp]||>
        - flag server tag_parser_result_temp:!
        - flag server tag_parser_record_temp:!
        - log "<util.time_now.format> [<[name]>] in [<[origin]>] recorded to <[recorded]> got result <[result]>" file:<server.flag[tag_parser_logpath]>
        crunch_result:
        - define final_result <empty>
        - foreach <[result].split[;]>:
            - if <[value].starts_with[VALID=]>:
                - define final_result <[final_result]><[value].after[VALID=].replace_text[&sc].with[;]><n>
        - foreach <[result].split[;]>:
            - if <[value].starts_with[FAILED=ERROR/]>:
                - define final_result "<[final_result]>Had error: <[value].after[FAILED=ERROR/].replace_text[&sc].with[;]><n>"
            - else if <[value].starts_with[FAILED=EXCEPTION/]>:
                - define final_result "<[final_result]>Had internal exception: <[value].after[FAILED=EXCEPTION/].replace_text[&sc].with[;]><n>"
            - else if <[value].starts_with[FAILED=]>:
                - define fail_reason <[value].after[FAILED=]>
                - if <[fail_reason]> == FLAG_MISSING:
                    - define final_result "<[final_result]>Got no result value.<n>"
                - else:
                    - define final_result "<[final_result]>Got failure '<[fail_reason]>'.<n>"
        - if <[final_result].trim.length> == 0:
            - define final_result <empty>
        - if <[final_result].length> > 1000 || <[tag].length.add[<[final_result].length>]> > 1500:
            - define tag (Spam)
            - define final_result "Input too long, refused."
        - if <[final_result].to_list.filter[is[==].to[<n>]].size> > 10:
            - define final_result "Newline spam, refused."
    events:
        on server start:
        - wait 5s
        - flag server tag_parser_bot_running:!
        - inject locally script_paths.start_bot
        on script generates error:
        - flag server tag_parser_result_temp:FAILED=ERROR/<context.message.escaped.replace_text[;].with[&sc]>;<server.flag[tag_parser_result_temp]||>
        on server generates exception:
        - flag server tag_parser_result_temp:FAILED=EXCEPTION/<context.type.escaped.replace_text[;].with[&sc]>-<context.message.escaped.replace_text[;].with[&sc]>;<server.flag[tag_parser_result_temp]||>
        on discord message received for:tag_parser:
        - flag server tag_parser_bot_running
        - if <yaml.list.contains_text[tag_parser_temp]>:
          - yaml unload id:tag_parser_temp
        - define name <context.new_message.author.id>/<context.new_message.author.name.escaped>
        - define origin <context.group>/<context.channel>/<context.group.name.escaped>/<context.channel.name.escaped>
        - announce to_console "Discord chatter! [<[name]>] in [<[origin]>] saying <context.new_message.text> and mentioning <context.new_message.mentioned_users>"
        - if !<context.new_message.mentioned_users.parse[id].contains[<context.bot.self_user.id>]>:
            - stop
        - if !<server.flag[tag_parser_validchannels].contains[<context.channel.id>]>:
            - define found <server.flag[tag_parser_barredchannels].find[<context.channel.id>]>
            - if <[found]> > 0:
                - discord id:tag_parser message channel:<context.channel> "Cannot parse that in this channel! <server.flag[tag_parser_barredchannelmessages].get[<[found]>]>"
            - stop
        - if <context.new_message.text_no_mentions.trim.escaped> == link:
            - discord id:tag_parser message channel:<context.channel> "The source script for **dTagParser** can be found at <&lt><server.flag[tag_parser_samples].as_map.get[link]><&gt>"
            - stop
        - waituntil rate:1s !<server.has_flag[tag_parser_bot_processing_now]>
        - flag server tag_parser_bot_processing_now duration:1m
        - define tag <context.new_message.text_no_mentions.replace_text[<n>].with[<&sp>].trim.escaped>
        - inject locally script_paths.process_tag player:<server.players.get[1]> npc:<server.npcs.get[1]>
        - inject locally script_paths.crunch_result
        - discord id:tag_parser message channel:<context.channel> "Tag parse results for `<[tag].unescaped.replace_text[`].with[']>`<&co> <[recorded]><n>```<n><[final_result].unescaped.replace_text[`].with[']>```"
        - flag server tag_parser_bot_processing_now:!

tag_run_task:
    type: task
    definitions: tag
    debug: false
    script:
    - define samples <server.flag[tag_parser_samples].as_map.with[sample_player].as[<player>].with[sample_npc].as[<npc>]>
    - foreach <[samples].keys> as:key:
        - define <[key]> <[samples].get[<[key]>]>
    - define help "Tell me any valid Denizen (Bukkit) tags, like <&lt>player.name<&gt> and I'll parse them for you! Alternately, tell me a valid definition name (like 'samples') and I'll tell you its contents."
    - if !<[tag].unescaped.contains_text[<&lt>]> && <[<[tag].unescaped>]||null> != null:
        - flag server tag_parser_result_temp:VALID=<[<[tag].unescaped>].escaped.replace_text[;].with[&sc]>;<server.flag[tag_parser_result_temp]||>
    - else:
        # don't uncomment these or i'll punch you
        #- debug record start
        - inject tag_parser_task
        #- ~debug record submit save:recorded
        #- define record_url <entry[recorded].submitted||null>
        - flag server tag_parser_result_temp:VALID=<[result]>;<server.flag[tag_parser_result_temp]||>
        #- if <[record_url]> == null:
        #    - define record_url "(Submit Failed)"
        #- else:
        #    - define record_url <&lt><[record_url]><&gt>
        #- flag server tag_parser_record_temp:<[record_url]>

tag_parser_task:
    type: task
    definitions: tag
    script:
    - define result <[tag].unescaped.parsed.escaped.replace_text[;].with[&sc]>