dependency.lic

=begin
  Documentation: https://elanthipedia.play.net/Lich_script_development#dependency
=end

require 'json'
require 'net/http'
require 'base64'
require 'yaml'
require 'ostruct'
require 'digest/sha1'
require 'monitor'

$DEPENDENCY_VERSION = '1.7.2'
$MIN_RUBY_VERSION = '3.2.2'

no_pause_all
no_kill_all

while Script.running?('repository')
  echo("Repository is running, pausing for 10 seconds.")
  pause 10
end

class Object
  # IMPORT FUTURE LAWLZ
  def itself
    self
  end
end

class ArgParser
  def parse_args(data, flex_args = false)
    raw_args = variable.first
    baselist = variable.drop(1).dup || []

    unless baselist.size == 1 && baselist.grep(/^help$|^\?$|^h$/).any?

      result = data.map { |definition| check_match(definition, baselist.dup, flex_args) }.compact

      return result.first if result.length == 1

      if result.empty?
        echo "***INVALID ARGUMENTS DON'T MATCH ANY PATTERN***"
        respond "Provided Arguments: '#{raw_args}'"
      elsif result.length > 1
        echo '***INVALID ARGUMENTS MATCH MULTIPLE PATTERNS***'
        respond "Provided Arguments: '#{raw_args}'"
      end

    end

    display_args(data)
    exit
  end

  def display_args(data)
    # This section displays help output for a script. It recognizes when a script call has been given
    # with the wrong number or incorrect arguments, or when a script has been called via
    # ;script-name help. It outputs an example script call, including arguments, with optional
    # arguments enclosed in brackets. If an optional script_summary argument has been specified within
    # the script, it also outputs a summary of the script. Further, if yaml settings have been
    # outlined in base-help.yaml, it will output help information for the yaml settings used.
    # Example output when all help settings have been specified:
    #
    # >;circlecheck help
    #   SCRIPT SUMMARY: Checks your circle and skills to next circle. Optionally checks skills for a target circle.
    #
    #   SCRIPT CALL FORMAT AND ARG DESCRIPTIONS (arguments in brackets are optional):
    #    ;circlecheck [debug] [mode] [target] [script_summary]
    #     debug        Runs the script with debug messages.
    #     mode         Only display requirements you don't meet [brief, short, next]
    #     target       See requirements for a specific circle
    #
    #   YAML SETTINGS USED:
    #     circlecheck_prettyprint: Tells circlecheck to use the pretty print formatting for output. [Ex: true/false]
    if Script.current.name != "bootstrap"
      data.each do |def_set|
        def_set
          .select { |x| x[:name].to_s == "script_summary" }
          .each { |x| respond " SCRIPT SUMMARY: #{x[:description]} " }
        respond ''
        respond " SCRIPT CALL FORMAT AND ARG DESCRIPTIONS (arguments in brackets are optional):"
        respond "  ;#{Script.current.name} " + def_set.map { |x| format_item(x) unless x[:name].to_s == "script_summary" }.join(' ')
        def_set
          .reject { |x| x[:name].to_s == "script_summary" }
          .each { |x| respond "   #{(x[:display] || x[:name]).ljust(12)} #{x[:description]} #{x[:options] ? '[' + x[:options].join(', ') + ']' : ''}" }
      end

      # Display help output for settings used in the script. Relies on base-help.yaml.
      yaml_data = get_data('help').to_h
      yaml_settings = yaml_data.select { |_field, info| info["referenced_by"].include?(Script.current.name) }

      unless yaml_settings.empty?
        respond ''
        respond " YAML SETTINGS USED:"
        yaml_settings.each do |field, info|
          setting_line += "   #{field}: #{info["description"]} #{info["specific_descriptions"][Script.current.name]}"
          setting_line += " [Ex: #{info["example"]}]" unless info["example"].to_s.nil? || info["example"].to_s.empty?
          respond setting_line
        end
        respond ""
      end
    end
  end

  private

  def matches_def(definition, item)
    echo "#{definition}:#{item}" if UserVars.parse_args_debug
    return true if definition[:regex] && definition[:regex] =~ item
    return true if definition[:options] && definition[:options].find { |option| item =~ /^#{option}#{'$' if definition[:option_exact]}/i }

    false
  end

  def check_match(defs, vars, flex)
    args = OpenStruct.new

    defs.reject { |x| x[:optional] }.each do |definition|
      return nil unless matches_def(definition, vars.first)

      args[definition[:name]] = vars.first.downcase
      vars.shift
    end

    defs.select { |x| x[:optional] }.each do |definition|
      if (match = vars.find { |x| matches_def(definition, x) })
        args[definition[:name]] = match.downcase
        vars.delete(match)
      end
    end

    if flex
      args.flex = vars

      # Check to see if a yaml profile has same name as script arg. Only matters when we're flexing
      # args and attempting to call a yaml profile with the flexed arg.
      profiles = Dir[File.join(SCRIPT_DIR, 'profiles/*.*')]
      profiles.each do |profile|
        profile = profile[/.*#{checkname}-(\w*).yaml/, 1]
        args.to_h.values.each do |arg|
          if arg == profile
            echo "WARNING: yaml profile '#{checkname}-#{arg}.yaml' matches script argument '#{arg}'."
            echo "Favoring the script argument. Rename the file if you intend to call it as a flexed settings file."
          end
        end
      end
    else
      return nil unless vars.empty?
    end

    args
  end

  def format_item(definition)
    item = definition[:display] || definition[:name]
    if definition[:optional]
      item = "[#{item}]"
    elsif definition[:variable] || definition[:options]
      item = "<#{item}>"
    end
    item
  end
end

def parse_args(defn, flex_args = false)
  ArgParser.new.parse_args(defn, flex_args)
end

def display_args(defn)
  ArgParser.new.display_args(defn)
end

arg_definitions = [
  [
    { name: 'debug', regex: /debug/i, optional: true },
    { name: 'install', regex: /install/i, optional: true }
  ]
]

args = parse_args(arg_definitions)

debug = args.debug || UserVars.debug_dependency
install = args.install

class ScriptManager
  attr_reader :autostarts

  def initialize(debug)
    unless XMLData.game =~ /^DR/
      echo("This script is not intended for usage with games other than Dragonrealms. Exiting now")
      exit
    end
    unless LICH_VERSION.match?(/^5/)
      _respond("<pushBold/>*****************************************************************************<popBold/>")
      _respond("<pushBold/>* Unsupported Lich versions detected.                                       *<popBold/>")
      _respond("<pushBold/>* Please see https://github.com/rpherbig/dr-scripts/wiki/First-Time-Setup   *<popBold/>")
      _respond("<pushBold/>* For an update path.                                                       *<popBold/>")
      _respond("<pushBold/>*****************************************************************************<popBold/>")
      exit
    end

    @debug = debug
    @paste_bin_token = 'dca351a27a8af501a8d3123e29af7981'
    @paste_bin_url = 'https://pastebin.com/api/api_post.php'
    @firebase_url = 'https://dr-scripts.firebaseio.com/'
    @status_repo = Settings['status_repo'] || 'rpherbig/dr-scripts'
    @status_branch = Settings['status_branch'] || 'master'
    update_status_url
    # Gating setting lich_url on lich version

    UserVars.autostart_scripts ||= []
    UserVars.autostart_scripts.uniq!
    UserVars.autostart_scripts = UserVars.autostart_scripts - ['dependency']
    Settings['autostart'] ||= []
    Settings['autostart'].uniq!
    Settings['autostart'] = Settings['autostart'] - ['dependency']

    # Setting Settings['lich_fork_sha'] to nil if using lich5. This setting isn't used anymore.

    Settings['base_versions'] ||= {}
    CharSettings['next_ruby_version_check_datetime'] = Time.now

    @add_autos = []
    @remove_autos = []
    update_autostarts
    @self_updated = false
    @thievery_queue = []
    @shop_update_queue = []

    @request_authorization = manage_github_token
    @versions = nil
  end

  def updated_dependency?
    @self_updated
  end

  def update_autostarts
    @autostarts = (UserVars.autostart_scripts + Settings['autostart']).uniq
  end

  def update_status_url
    @status_url = 'https://api.github.com/repos/' + @status_repo + '/git/trees/' + @status_branch
  end

  def set_custom_status_repo(repo, branch)
    @status_repo = repo
    @status_branch = branch
    update_status_url
  end

  def set_custom_status_branch(branch)
    @status_branch = branch
    update_status_url
  end

  def unset_custom_status
    @status_repo = 'rpherbig/dr-scripts'
    @status_branch = 'master'
    update_status_url
  end

  def check_custom_status
    @status_url
  end

  def add_global_auto(script)
    @add_autos << script
  end

  def remove_global_auto(script)
    @remove_autos << script
  end

  def get_versions
    if @versions
      @versions
    else
      @versions = build_version_hash
    end
  end

  def build_version_hash
    Dir[File.join(SCRIPT_DIR, '*.lic')].each_with_object({}) do |path, versions|
      file = File.basename(path)
      body = File.open(File.join(SCRIPT_DIR, "#{file}"), 'r').readlines.join('')
      sha = Digest::SHA1.hexdigest('blob' + " #{body.size}" + "\0" + body)
      versions[file] = sha
    end
  end

  def autos_proccessed?
    @add_autos.empty? && @remove_autos.empty?
  end

  def queue_thieving_update(id, update)
    @thievery_queue << [id, update]
  end

  def queue_shop_update(shop_data)
    @shop_update_queue << shop_data
  end

  def run_queue
    validate_supported_ruby_version
    Settings['status_repo'] = @status_repo
    Settings['status_branch'] = @status_branch
    update = false

    unless @add_autos.empty?
      update = true
      @add_autos.each { |script| Settings['autostart'] << script }
      @add_autos = []
    end
    unless @remove_autos.empty?
      update = true
      @remove_autos.each { |script| Settings['autostart'].delete(script) }
      @remove_autos = []
    end

    submit_thieving_update(*@thievery_queue.pop) unless @thievery_queue.empty?
    submit_shop_update(@shop_update_queue.pop) unless @shop_update_queue.empty?
    update_autostarts if update
  end

  def submit_shop_update(shop_data)
    partial = shop_data[:surfaces].nil?

    key = "#{shop_data[:root_room]}-#{shop_data[:entrance]}"

    uri = URI.parse("#{@firebase_url}/shop-data/#{key}.json")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    begin
      request = partial ? Net::HTTP::Patch.new(uri.request_uri) : Net::HTTP::Put.new(uri.request_uri)
      request['Content-Type'] = 'application/json'
      request.body = shop_data.to_json
      response = http.request(request)
      response.body.chomp
    rescue => e
      echo(e)
      echo('Error in submitting shop data')
    end
  end

  def get_script(filename, force = false)
    filename = filename.dup
    echo("checking:#{filename} force:#{force}") if @debug
    download_script(filename, force)
  end

  def repo_scripts
    $manager.get_status['tree'].map { |element| element['path'] }.select { |file| file.include?('.lic') && !file.include?('-setup') }
  end

  def start_scripts(force = false)
    @versions = nil
    repo_scripts.each { |(name, _)| get_script(name, force) }
    autostarts.each do |script|
      if script == 'drinfomon'
        respond "\n---\ndrinfomon found in autostarts. This method is no longer used. Attempting to remove it now. If unsuccessful, it can be safely removed with `#{$clean_lich_char}e stop_autostart('drinfomon')`\n---\n"
        stop_autostart('drinfomon')
        next
      end
      custom_require.call(script)
      loop do
        pause 0.2
        break unless !Script.running.find_all { |s| s.name =~ /bootstrap/ }.empty?
      end
    end
  end

  def download_script(filename, force = false)
    return if filename.nil? || filename.empty?

    echo("downloading:#{filename}") if @debug
    info = get_file_status(filename)
    return unless info
    return if get_versions[filename] == info['sha'] && !force

    echo("info:#{info}") if @debug
    blob = make_request(info['url'])
    File.open(File.join(SCRIPT_DIR, "#{filename}"), 'w') { |file| file.print(Base64.decode64(blob['content'])) }

    @self_updated = true if filename == 'dependency.lic'
  end

  def verify_or_make_dir(path)
    Dir.mkdir(path) unless Dir.exist?(path)
  end

  def setup_profiles
    verify_or_make_dir File.join(SCRIPT_DIR, 'profiles')
    profile_tree_url = get_status['tree'].find { |element| element['path'] == 'profiles' }['url']
    make_request(profile_tree_url)['tree']
      # Select only base.yaml and base-empty.yaml
      .select { |data| /^base(?:-empty)?\.yaml/ =~ data['path'] }
      .each do |setup_file|
        echo("downloading #{setup_file}") if @debug
        blob = make_request(setup_file['url'])
        File.open(File.join(SCRIPT_DIR, "profiles/#{setup_file['path']}"), 'w') { |file| file.print(Base64.decode64(blob['content'])) }
      end
  end

  def setup_data
    verify_or_make_dir File.join(SCRIPT_DIR, 'data')
    data_tree_url = get_status['tree'].find { |element| element['path'] == 'data' }['url']
    make_request(data_tree_url)['tree'].each do |setup_file|
      echo("downloading #{setup_file}") if @debug
      blob = make_request(setup_file['url'])
      File.open(File.join(SCRIPT_DIR, "data/#{setup_file['path']}"), 'w') { |file| file.print(Base64.decode64(blob['content'])) }
    end
  end

  def update_local_stealing_yaml(id, update, new_entry = false)
    stealing_path = File.join(SCRIPT_DIR, 'data/base-stealing.yaml')
    stealing_data = $setupfiles.safe_load_yaml(stealing_path)
    result = nil
    if new_entry
      stealing_data[:stealing_options].push(update)
    else
      stealing_data[:stealing_options].each do |data|
        if data['id'] == id
          result = data.dup
          data.merge!(update)
        end
      end
    end
    File.open(stealing_path, 'w') { |file| file.print(stealing_data.to_yaml) }
    result
  end

  def check_base_files
    verify_or_make_dir File.join(SCRIPT_DIR, 'profiles')
    profile_tree_url = get_status['tree'].find { |element| element['path'] == 'profiles' }['url']
    make_request(profile_tree_url)['tree']
      # Select only base.yaml and base-empty.yaml
      .select { |data| /^base(?:-empty)?\.yaml/ =~ data['path'] }
      # Reject files that exist, and have the same shasum as those on the repo.
      .reject { |setup_file| File.exist?("profiles/#{setup_file['path']}") && setup_file['sha'] == Settings['base_versions'][setup_file['path']] }
      .each do |setup_file|
        echo("downloading #{setup_file}") if @debug
        blob = make_request(setup_file['url'])
        File.open(File.join(SCRIPT_DIR, "profiles/#{setup_file['path']}"), 'w') { |file| file.print(Base64.decode64(blob['content'])) }
        Settings['base_versions'][setup_file['path']] = setup_file['sha']
      end
  end

  def check_data_files
    verify_or_make_dir File.join(SCRIPT_DIR, 'data')
    profile_tree_url = get_status['tree'].find { |element| element['path'] == 'data' }['url']
    make_request(profile_tree_url)['tree']
      .select { |data| /^base.+yaml/ =~ data['path'] }
      # Reject files that exist, and have the same shasum as those on the repo.
      .reject { |setup_file| File.exist?("data/#{setup_file['path']}") && setup_file['sha'] == Settings['base_versions'][setup_file['path']] }
      .each do |setup_file|
        echo("downloading #{setup_file}") if @debug
        blob = make_request(setup_file['url'])
        File.open(File.join(SCRIPT_DIR, "data/#{setup_file['path']}"), 'w') { |file| file.print(Base64.decode64(blob['content'])) }
        Settings['base_versions'][setup_file['path']] = setup_file['sha']
      end
  end

  def run_script(filename)
    filename.sub!(/\.lic$/, '')
    echo("refresh:#{filename}") if @debug
    stop_script(filename) if Script.running?(filename)
    pause 0.1 while Script.running?(filename)
    start_script(filename)
  end

  def file_outdated?(filename)
    echo("file_outdated?:#{filename}") if @debug
    local_version = get_versions[filename]
    echo("local:#{local_version}") if @debug
    info = get_file_status(filename)
    unless info
      echo("file not found in repository: #{filename}")
      return false
    end
    echo("remote:#{info['sha']}") if @debug
    info['sha'] != local_version
  end

  def get_file_status(filename)
    get_status['tree'].find { |element| element['path'] == filename }
  end

  def get_status
    return @status if @status && Time.now - @status_time <= 30 # prevent flooding

    @status_time = Time.now
    @status = make_request(@status_url)
  end

  def make_request(raw_uri)
    echo "make_request:raw_uri = #{raw_uri}" if @debug
    uri = URI.parse(raw_uri)
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    request = Net::HTTP::Get.new(uri.request_uri)
    request['Authorization'] = @request_authorization

    response = http.request(request)
    JSON.parse(response.body)
  end

  def manage_github_token
    # This method manages some checking of the GitHub token we'll be using. We allow a personal
    # GitHub token to be specified in the /data folder, or we can use the general Lich token.
    # If using a personal GitHub token, we'll verify the token is valid, and we'll also do some
    # checking of the rate limit for the token we're using. If the rate limit is above a certain
    # threshold, we'll warn but won't fail, as Lich can still function when the rate limit is
    # exceeded, albeit with some reduced functionality.
    #  Returns: request['Authorization'] token string

    github_token = [
      'Z2hwX21XN1',
      'V0RkdORXdGYlpmVDF1S3AzM2I1TV',
      'J5bHlTNjBXc09VNw==',
      '\n'
    ].join('')

    # Set up our rate limit check URL and items
    url = URI("https://api.github.com/rate_limit")
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    request = Net::HTTP::Get.new(url)

    # Check if the user has a githubtoken.txt file and use the token in that file if so. If they
    # do have a personal token specified, verify valid. Else, use general token. Note: the .strip
    # is apparently necessary to have the File.read function in Linux.
    if File.exist?("#{DATA_DIR}/githubtoken.txt")
      echo "Using personal GitHub token."
      request['Authorization'] = "token #{File.read("#{DATA_DIR}/githubtoken.txt").strip}"

      # Verify the GitHub token is valid. If not, swap to the general token.
      if http.request(request).body =~ /Bad credentials/
        echo "Bad personal GitHub token. Reverting to Lich's general token."
        echo "Please update /lich/data/githubtoken.txt"
        request['Authorization'] = "token #{Base64.decode64(github_token)}"
      end
    else
      echo "Using general GitHub token." if @debug
      request['Authorization'] = "token #{Base64.decode64(github_token)}"
    end

    response = http.request(request)
    parsed_response = JSON.parse(response.body)

    used = parsed_response["resources"]["core"]["used"].to_i
    limit = parsed_response["resources"]["core"]["limit"].to_i

    echo "Current token rate limit usage: #{used}/#{limit}" if @debug

    # Warn if rate limit is currently above 80% usage.
    if used.to_f / limit >= 0.8 && @debug
      echo ""
      echo "*** WARNING: GitHub rate currently #{used}/#{limit} ***"
      echo "*** Please report in Discord or GitHub. ***"
      echo ""
    end

    return request['Authorization']
  end

  def submit_thieving_update(id, update)
    return submit_new_thieving_item(id, update) if update.delete('new')

    old_data = update_local_stealing_yaml(id, update)

    # return

    data = get_current_stealing_data(id)

    update.delete_if do |key, value|
      echo("checking:#{data[key]}:#{old_data[key]}") if UserVars.crossing_trainer_debug
      key =~ /_min$/ ? data[key] && data[key] != old_data[key] && value >= data[key] : data[key] && data[key] != old_data[key] && value <= data[key]
    end

    if update.empty?
      echo('Nothing left to update') if UserVars.crossing_trainer_debug
      return
    end

    echo("submitting:#{id}:#{update}") if UserVars.crossing_trainer_debug
    uri = URI.parse("#{@firebase_url}/stealing-options/#{id}.json")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    request = Net::HTTP::Patch.new(uri.request_uri)
    request['Content-Type'] = 'application/json'
    request.body = update.to_json
    response = http.request(request)
    response.body.chomp
  end

  def submit_new_thieving_item(id, data)
    id = (id.to_i + 1).to_s while get_current_stealing_data(id)

    data['id'] = id

    update_local_stealing_yaml(id, data, true)

    echo("submittingNEW:#{id}:#{data}") if UserVars.crossing_trainer_debug

    uri = URI.parse("#{@firebase_url}/stealing-options/#{id}.json")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    request = Net::HTTP::Put.new(uri.request_uri)
    request['Content-Type'] = 'application/json'
    request.body = data.to_json
    response = http.request(request)
    response.body.chomp
  end

  def get_current_stealing_data(id)
    uri = URI.parse("#{@firebase_url}/stealing-options/#{id}.json")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    request = Net::HTTP::Get.new(uri.request_uri)
    request['Content-Type'] = 'application/json'
    response = http.request(request)
    return nil if response.body.nil?

    begin
      JSON.parse(response.body.chomp)
    rescue
      return nil
    end
  end

  def make_map_edits
    echo("Applying personal map overrides")
    # Get base and personal wayto overrides
    base_wayto_overrides = get_settings.base_wayto_overrides
    personal_wayto_overrides = get_settings.personal_wayto_overrides
    # Merge the two hashes into a single hash, favoring personal overrides for duplicate keys.
    wayto_overrides = base_wayto_overrides.merge(personal_wayto_overrides)
    # Iterate through the aggregated map wayto overrides from above and set new stringprocs
    wayto_overrides.each do |_key, values|
      start_room_id = values['start_room'].to_i
      end_room_id = values['end_room'].to_i
      start_room = Map.list[start_room_id]
      old_wayto = start_room.wayto["#{end_room_id}"]
      old_timeto = start_room.timeto["#{end_room_id}"]
      new_wayto = old_wayto
      new_timeto = old_timeto
      if values['str_proc']
        new_wayto = StringProc.new("#{values['str_proc']}")
      end
      if values['travel_time']
        new_timeto = values['travel_time'].to_f
      end
      start_room.wayto["#{end_room_id}"] = new_wayto
      start_room.timeto["#{end_room_id}"] = new_timeto
    end
    # Pull personal map custom targets, if any
    personal_map_targets = get_settings.personal_map_targets
    if personal_map_targets
      custom_targets = (GameSettings['custom targets'] || Hash.new)
      custom_targets.merge!(personal_map_targets)
      GameSettings['custom targets'] = custom_targets
    end
  end
end

class BankbotManager
  def initialize(debug)
    @debug = debug
    @save = false
    @load = false
    @transaction = ''
    @ledger = {}
  end

  attr_reader :ledger

  def loaded?
    !@load
  end

  def run_queue
    save_transaction
    load_ledger
  end

  def save_bankbot_transaction(transaction, ledger)
    @transaction = transaction
    @ledger = ledger.to_yaml
    @save = true
  end

  def load_bankbot_ledger
    @load = true
  end

  private

  def save_transaction
    return unless @save

    File.open(File.join(LICH_DIR, "#{checkname}-transactions.log"), 'a') do |file|
      file.puts('----------')
      file.puts(Time.now)
      file.puts(@transaction)
      file.puts(@ledger)
      file.puts('----------')
    end
    File.open(File.join(LICH_DIR, "#{checkname}-ledger.yaml"), 'wb') { |file| file.puts(@ledger) }
    @save = false
  end

  def load_ledger
    return unless @load

    @ledger = safe_load_yaml("./#{checkname}-ledger.yaml")
    @load = false
  end

  def safe_load_yaml(path)
    if (RUBY_VERSION =~ /^2/)
      OpenStruct.new(YAML.load_file(path)).to_h
    elsif (RUBY_VERSION =~ /^3/)
      OpenStruct.new(YAML.unsafe_load_file(path)).to_h
    end
  rescue => e
    echo('*** ERROR PARSING YAML FILE ***')
    echo(e.message)
    return {}
  end
end

class ReportbotManager
  def initialize(debug)
    @debug = debug
    @save = false
    @load = false
    @whitelist = []
  end

  attr_reader :whitelist

  def loaded?
    !@load
  end

  def run_queue
    save_whitelist
    load_whitelist
  end

  def save_reportbot_whitelist(whitelist)
    @whitelist = whitelist.to_yaml
    @save = true
  end

  def load_reportbot_whitelist
    @load = true
  end

  private

  def save_whitelist
    return unless @save

    File.open(File.join(LICH_DIR, 'reportbot-whitelist.yaml'), 'wb') { |file| file.puts(@whitelist) }
    @save = false
  end

  def load_whitelist
    return unless @load

    @whitelist = safe_load_yaml('./reportbot-whitelist.yaml')
    @load = false
  end

  def safe_load_yaml(path)
    if (RUBY_VERSION =~ /^2/)
      YAML.load_file(path)
    elsif (RUBY_VERSION =~ /^3/)
      YAML.unsafe_load_file(path)
    end
  rescue => e
    echo('*** ERROR PARSING YAML FILE ***')
    echo(e.message)
    return []
  end
end

class SlackbotManager
  def initialize(debug)
    @debug = debug
    @slackbot = nil
    @username = nil
    @messages = []
  end

  def run_queue
    register_slackbot
    send_messages
  end

  def register(username)
    return if @slackbot

    @username = username
  end

  def queue_message(message)
    return unless message

    @messages << message
  end

  private

  def register_slackbot
    return unless @username
    return unless @slackbot.nil?

    echo("Registering Slackbot")
    custom_require.call('slackbot')
    @slackbot = SlackBot.new
  end

  def send_messages
    return unless @slackbot

    until @messages.empty?
      message = @messages.shift
      @slackbot.direct_message(@username, message)
    end
  end
end

class SetupFiles
  # http://www.druby.org/sidruby/5-3-thread-safe-communication-using-locking-mutex-and-monitormixin.html#sec.monitormixin
  include MonitorMixin

  class FileInfo
    attr_reader :path, :name, :mtime

    def initialize(path:, name:, data:, mtime:)
      @path = path
      @name = name
      @data = data
      @mtime = mtime
    end

    def data
      # Create deep clone of data to mitigate scripts changing settings in-memory
      # because that leads to hard to track down bugs and unpredictable script behaviors.
      Marshal.load(Marshal.dump(@data))
    end

    def peek(property)
      # An efficient and safe way to return a specific property
      # from the yaml file without the risks of passing around shallow copies.
      # This marshals the one property which is magnitudes faster than
      # marshalling the entire file to access one property.
      Marshal.load(Marshal.dump(@data[property.to_sym]))
    end

    def to_s
      File.join(@path, @name)
    end

    def inspect
      "#<SetupFiles::FileInfo @name=#{@name}, @path=#{@path}, @mtime=#{@mtime}>"
    end
  end

  def initialize(debug = false)
    super() # Must call super() to initialize the MonitorMixin
    @files_cache = {} # map of filenames => FileInfo objects
    @debug = debug
  end

  def safe_load_yaml(filepath)
    if (RUBY_VERSION =~ /^2/)
      OpenStruct.new(YAML.load_file(filepath)).to_h
    elsif (RUBY_VERSION =~ /^3/)
      OpenStruct.new(YAML.unsafe_load_file(filepath)).to_h
    end
  rescue => e
    echo('*** ERROR PARSING YAML FILE ***')
    echo(e.message)
    return {}
  end

  # Returns your character's settings.
  # base.yaml, base-empty.yaml, and MyChar-setup.yaml are always loaded.
  # You can also provide an array of character yaml suffixes to load additionally.
  # For example, ['hunt'] to load 'scripts/profiles/MyChar-hunt.yaml'.
  # The suffixes feature is primarily used by hunting-buddy.
  def get_settings(character_suffixes = [])
    character_suffixes = ['setup', character_suffixes].flatten.compact.uniq
    character_filenames = character_suffixes_to_filenames(character_suffixes)
    # Ensure latest profiles are loaded into cache
    reload_profiles(character_filenames)
    # Get 'include' filenames, suffixes to other files where players externalize
    # reusable settings that they share/include in other character setting files.
    include_filenames = character_filenames
                        .reduce([]) do |result, filename|
                          result + (cache_get_by_filename(filename).peek('include') || [])
                        end
                        .map do |suffix|
      to_include_filename(suffix)
    end
    reload_profiles(include_filenames)
    # Merge base and character settings
    settings = [
      'base.yaml',
      'base-empty.yaml',
      include_filenames,
      character_filenames
    ].flatten.reduce({}) do |result, filename|
      result.merge(cache_get_by_filename(filename).data || {})
    end
    # Transform settings for quality of life improvements
    transform_settings(settings)
  end

  # Returns the config in a 'scripts/data/base-{type}.yaml' file.
  # For example, type could be 'spells' or 'town' to return base-spells.yaml or base-town.yaml.
  def get_data(type)
    filename = to_base_filename(type)
    # Ensure latest data is loaded into cache
    reload_data([filename])
    # Transform data for quality of life improvements
    transform_data(cache_get_by_filename(filename).data)
  end

  # Designed to be called once before dependency enters its run loop.
  # Purpose is to check for file changes and reload them into cache.
  def reload
    reload_profiles(character_suffixes_to_filenames(['setup']))
    reload_data
  end

  private

  SCRIPTS_DATA_PATH = File.join(SCRIPT_DIR, 'data')

  # use alternate location for settings to allow folks to use lich with
  # alternate configurations in Test/Platinum/Fallen
  if File.exist?(File.join(DATA_DIR, XMLData.game, "base.yaml")) && File.exist?(File.join(DATA_DIR, XMLData.game, "base-empty.yaml")) && File.exist?(File.join(DATA_DIR, XMLData.game, "#{checkname}-setup.yaml"))
    echo("Detected game instance-specific files. Loading settings from #{File.join(DATA_DIR, XMLData.game)}")
    SCRIPTS_PROFILES_PATH = File.join(DATA_DIR, XMLData.game)
  else
    SCRIPTS_PROFILES_PATH = File.join(SCRIPT_DIR, 'profiles')
  end

  # Reloads the base profiles plus any that match the filenames given.
  def reload_profiles(filenames = [])
    load_files(get_profiles_glob_patterns(filenames))
  end

  # Reloads the base data plus any that match the filenames given.
  def reload_data(filenames = [])
    load_files(get_data_glob_patterns(filenames))
  end

  # Gets glob patterns for the profiles directory.
  # Includes base profiles plus any specified in the filenames argument.
  def get_profiles_glob_patterns(filenames = [])
    get_glob_patterns(SCRIPTS_PROFILES_PATH, filenames)
  end

  # Gets glob patterns for the data directory.
  # Includes base data plus any specified in the filenames argument.
  def get_data_glob_patterns(filenames = [])
    get_glob_patterns(SCRIPTS_DATA_PATH, filenames)
  end

  # Generates an array of file glob patterns, one per filename in the given basepath.
  # `base*.yaml` is automatically and always included in the glob pattern.
  def get_glob_patterns(basepath = '.', filenames = [])
    # base* yamls define initial setting defaults.
    # include* yamls allow players to organize their settings into files
    # and then reference them in their character specific setup yamls.
    # The use of include yamls promotes reuse, which is a big win
    # for players with several characters.
    filenames = ["base*.yaml", "include*.yaml", filenames].flatten.compact.uniq
    filenames.map { |filename| File.join(basepath, File.basename(filename)) }
  end

  # Given an array of suffixes like ['setup'] or ['setup', 'hunt'] then
  # returns an array of those values mapped to filenames "{CharacterName}-{suffix}.yaml"
  def character_suffixes_to_filenames(character_suffixes)
    character_suffixes.map { |suffix| to_character_filename(suffix) }
  end

  # Returns the filename to a character yaml file for the given suffix.
  # For example 'setup' returns '{character}-setup.yaml'.
  def to_character_filename(suffix)
    "#{checkname}-#{suffix}.yaml"
  end

  # Returns the filename to a base yaml file for the given suffix.
  # For example 'spells' returns 'base-spells.yaml'.
  def to_base_filename(suffix)
    "base-#{suffix}.yaml"
  end

  # Returns the filename to an include yaml file for the given suffix.
  # For example 'spells' returns 'include-spells.yaml'.
  def to_include_filename(suffix)
    "include-#{suffix}.yaml"
  end

  # Iterates the files matched by the glob pattern and for those that
  # have been modified since the last time they were cached then those
  # are read from disk and cached. Unchanged files are not read again.
  def load_files(glob_patterns = [])
    self.synchronize do
      echo "#{self.class}::#{__callee__} glob_patterns=#{glob_patterns}" if @debug
      glob_patterns.each do |glob_pattern|
        Dir.glob(glob_pattern)
           .uniq
           .select { |filepath| File.file?(filepath) } # ignore directories
           .each do |filepath|
          filename = File.basename(filepath)
          last_modified_date = File.mtime(filepath)
          cached_file = cache_get_by_filename(filename)
          echo "#{self.class}::#{__callee__} filepath=#{filepath}, last_modified_date=#{last_modified_date}, cached_file=#{cached_file.inspect}" if @debug
          if cached_file.mtime != last_modified_date
            cache_put_by_filepath(filepath)
          end
        end
      end
    end
  end

  # Loads the yaml file contents into the file cache.
  # Uses the filename as the cache key.
  def cache_put_by_filepath(filepath)
    self.synchronize do
      echo "#{self.class}::#{__callee__} filepath=#{filepath}" if @debug
      @files_cache[File.basename(filepath)] = SetupFiles::FileInfo.new(
        path: File.dirname(filepath),
        name: File.basename(filepath),
        mtime: File.mtime(filepath),
        data: safe_load_yaml(filepath)
      )
    end
  end

  # Returns the cached file info for the given filename.
  # Uses the filename as the cache key.
  def cache_get_by_filename(filename)
    echo "#{self.class}::#{__callee__} filename=#{filename}" if @debug
    @files_cache[filename]
  end

  # Enrich settings with base data (e.g. fill in gaps for spells),
  # migrate legacy settings where appropriate, and other QOL tweaks.
  def transform_settings(original_settings)
    echo "#{self.class}::#{__callee__}" if @debug

    # Enable dot access to top-level properties (e.g. settings.hometown)
    settings = OpenStruct.new(original_settings)

    # Get data to enrich settings
    base_data_items = get_data('items')
    base_data_spells = get_data('spells')
    base_data_empty = get_data('empty')

    battle_cries_data = base_data_spells.battle_cries
    spells_data = base_data_spells.spell_data
    empty_data = base_data_empty.empty_values

    # Populate nil settings with default empty arrays/hashes
    # to mitigate "can't convert NilClass to Array" errors.
    # Note we don't merge to overwrite, we merge to assign if nil.
    empty_data.each { |name, value| settings[name] ||= value }

    # Find spell data by its name, case insensitive.
    get_spell_data_by_name = lambda do |name_to_find|
      # This creates a new map filtered to only the entries that match the spell name.
      spell_matches = spells_data.select { |name, _data| name.casecmp?(name_to_find) }
      # It's theoretically possible, though unlikely, that multiple
      # entries were returned if base data had the same spell listed
      # with different capitalization. Let's take the first entry we found.
      spell_match = spell_matches.first
      # We now have a map of spell name to map of spell properties.
      # What we want to return is just the map of spell properties.
      # Maps are treated as two-element arrays, first is the key, last is the value.
      # So we grab the last element which leaves us with map of spell properties.
      spell_data = spell_match.last
      # Inject spell name into the spell properties.
      # Some scripts check for either `abbrev` or `name`
      # but our base spells data doesn't have name as a property, so we set it.
      spell_data['name'] ||= spell_match.first

      spell_data
    end

    # Find spell data by its abbreviation, case insensitive.
    get_spell_data_by_abbrev = lambda do |abbrev_to_find|
      # This creates a new map filtered to only the entries that match the spell abbreviation.
      spell_matches = spells_data.select { |_name, data| data['abbrev'].casecmp?(abbrev_to_find) }
      # It's theoretically possible, though unlikely, that multiple
      # entries were returned if base data had the same spell listed
      # with different capitalization. Let's take the first entry we found.
      spell_match = spell_matches.first
      # We now have a map of spell name to map of spell properties.
      # What we want to return is just the map of spell properties.
      # Maps are treated as two-element arrays, first is the key, last is the value.
      # So we grab the last element which leaves us with map of spell properties.
      spell_data = spell_match.last
      # Inject spell name into the spell properties.
      # Some scripts check for either `abbrev` or `name`
      # but our base spells data doesn't have name as a property, so we set it.
      spell_data['name'] ||= spell_match.first

      spell_data
    end

    # Given a hash for a single spell definition,
    # populates unset properties with base spells data.
    #
    # For example:
    # if spell data has:
    #   { name: 'Death Monkey', abbrev: 'DM', mana: 5, skill: 'Targeted Magic' }
    #
    # and your spell setting in your yaml has:
    #   { abbrev: 'DM', mana: 8 }
    #
    # then this method returns the enriched spell configuration as:
    #   { name: 'Death Monkey', abbrev: 'DM', mana: 8, skill: 'Targeted Magic' }
    #
    enrich_spells_with_data_block = lambda do |spell_setting|
      return spell_setting unless spell_setting.is_a?(Hash)

      spell_data = get_spell_data_by_name.call(spell_setting['name']) ||
                   get_spell_data_by_abbrev.call(spell_setting['abbrev'])
      (spell_data || {}).merge(spell_setting)
    end

    # Given a hash of spell names to spell definitions,
    # populates the `name:` property on the spell definition if it's missing.
    #
    # Because the the map keys are themselves the spell names,
    # some players don't repeat the `name:` or `abbrev:` property
    # in the spell setting. However, we need that information
    # in order to enrich the spell setting with base data.
    #
    # For example:
    # if spells map has:
    #   { 'Devour': { 'use_auto_mana': true }, 'wound_level_threshold': 2 }
    #
    # then this method returns the enriched spell configuration as:
    #   { 'Devour': { 'name': 'Devour', 'use_auto_mana': true }, 'wound_level_threshold': 2 }
    #
    enrich_spells_with_name_block = lambda do |spells_map|
      spells_map.each do |spell_name, spell_setting|
        # Sometimes these maps support keys other than spell names,
        # such as numeric thresholds or other related script settings.
        # Check if this setting is a hash to avoid "no implicit conversion" errors
        # when we try to access the `name` property.
        if spell_setting.is_a?(Hash)
          spell_setting['name'] ||= spell_name
        end
      end
    end

    # Waggle sets are maps of arbitrary names to map of spell names to map of spell properties.
    # For example:
    #   { 'burgle': { 'Refractive Field': { abbrev: 'RF' ... }, 'Death Monkey': { ... } } }
    # Iterate each waggle's list of spells to enrich them.
    # Enrich each's spell definition by merging base spell data with spell settings.
    settings.waggle_sets.transform_values! do |spells_map|
      # For non-magic users it's actually an array of ability names, not spells.
      if spells_map.is_a?(Hash)
        enrich_spells_with_name_block.call(spells_map)
        spells_map.transform_values!(&enrich_spells_with_data_block)
      else
        spells_map
      end
    end

    # Spell settings that are maps of spell names to map of spell properties.
    # For example:
    #   { 'Manifest Force': { abbrev: 'MAF', mana: 5 ... } }
    # Enrich each's spell definition by merging base spell data with spell settings.
    [
      settings.buff_spells,
      settings.necromancer_healing,
    ].each do |spells_map|
      enrich_spells_with_name_block.call(spells_map)
      spells_map.transform_values!(&enrich_spells_with_data_block)
    end

    # Spell settings that are magic skill names to map of spell properties.
    # For example, { 'Augmentation': { abbrev: 'MAF' ... } }
    # Enrich each's spell definition by merging base spell data with spell settings.
    [
      settings.buff_spells,
      settings.combat_spell_training,
      settings.cyclic_training_spells,
      settings.magic_training,
      settings.training_spells,
      settings.crafting_training_spells,
      settings.necromancer_healing,
    ].each do |spells_map|
      # For non-magic users it's actually an array of ability names, not spells.
      next unless spells_map.is_a?(Hash)

      # Because the map keys are skill names, not spell names,
      # we have to assume the spell name or abbrev are defined in the setting.
      spells_map.transform_values!(&enrich_spells_with_data_block)
    end

    # Spell settings that are configured as a list whose values are maps of spell properties.
    # Enrich each's spell definition by merging base spell data with spell settings.
    [
      settings.offensive_spells
    ].each do |spells_list|
      # Because there is no other context to know which spell the setting is for
      # we have to assume the spell name or abbrev are defined in the setting.
      spells_list.map!(&enrich_spells_with_data_block)
    end

    # Spell settings that are configured as a map of a single spell's properties.
    # Enrich each's spell definition by merging base spell data with spell settings.
    [
      'crossing_training_sorcery',
    ].each do |key|
      settings[key] = enrich_spells_with_data_block.call(settings[key])
    end

    # For TM spells, default their 'prep' command to 'target'
    # unless a custom 'prep' command is already specified.
    settings.offensive_spells.each do |spell_setting|
      spell_data = spells_data[spell_setting['name']]
      is_native_tm = spell_setting['skill'] == 'Targeted Magic'
      is_sorcery_tm = spell_setting['skill'] == 'Sorcery' && spell_data['skill'] == 'Targeted Magic'
      if is_native_tm || is_sorcery_tm
        spell_setting['prep'] ||= 'target'
      end
    end

    # Battle Cries
    settings.battle_cries.map! do |battle_cry_setting|
      battle_cry_data = battle_cries_data[battle_cry_setting['name']]
      (battle_cry_data || {}).merge(battle_cry_setting)
    end

    # Lootables
    settings.lootables = (
      base_data_items.lootables +
      base_data_items.box_nouns +
      base_data_items.gem_nouns +
      base_data_items.scroll_nouns +
      settings.loot_additions -
      settings.loot_subtractions
    ).uniq

    # Pull sensitive settings from UserVars.
    # This is legacy from when people would commit and share their
    # yaml files on GitHub so that specific rooms and names were not exposed.
    settings.crossing_training_sorcery_room ||= UserVars.crossing_training_sorcery_room
    settings.compost_room ||= UserVars.compost_room
    settings.engineering_room ||= UserVars.engineering_room
    settings.outfitting_room ||= UserVars.outfitting_room
    settings.alchemy_room ||= UserVars.alchemy_room
    settings.safe_room ||= UserVars.safe_room
    settings.safe_room_id ||= UserVars.safe_room_id
    settings.safe_room_empath ||= UserVars.safe_room_empath
    settings.safe_room_empaths += (UserVars.safe_room_empaths || [])
    settings.slack_username ||= UserVars.slack_username
    settings.bankbot_name ||= UserVars.bankbot_name
    settings.bankbot_room_id ||= UserVars.bankbot_room_id
    settings.prehunt_buffs ||= UserVars.prehunt_buffs
    settings.hometown ||= UserVars.hometown
    settings.hometown = $HOMETOWN if $HOMETOWN

    # If these room settings are defined as maps with a
    # room id configured per town, then grab the hometown room id
    # and assign it directly to the setting.
    [
      'alchemy_room',
      'bankbot_room_id',
      'compost_room',
      'crossing_training_sorcery_room',
      'enchanting_room',
      'engineering_room',
      'feed_cloak_room',
      'forage_override_room',
      'lockpick_room_id',
      'outdoor_room',
      'outfitting_room',
      'prehunt_buffing_room',
      'safe_room',
      'safe_room_id',
      'theurgy_prayer_mat_room'
    ].each do |setting_name|
      if settings[setting_name].is_a?(Hash)
        hometown_value = settings[setting_name][settings.hometown]
        settings[setting_name] = hometown_value if hometown_value
      end
    end

    # Merge legacy appraisal settings into target appraisal settings
    if !settings.appraisal_training.include?('pouches') && settings.train_appraisal_with_pouches
      settings.appraisal_training.append('pouches')
    end
    if !settings.appraisal_training.include?('gear') && settings.train_appraisal_with_gear
      settings.appraisal_training.append('gear')
    end

    # Merge legacy astrology training settings into target training settings
    if !settings.astrology_training.include?('events') && settings.predict_event
      settings.astrology_training.append('events')
    end
    if !settings.astrology_training.include?('ways') && settings.astral_plane_training['train_in_ap']
      settings.astrology_training.append('ways')
    end

    return settings
  rescue => e
    echo "*** ERROR TRANSFORMING SETTINGS IN DEPENDENCY ***"
    echo "*** Commonly this due to malformed config in your yaml file ***"
    echo e.message
    e.backtrace.each { |msg| echo msg }
    OpenStruct.new
  end

  def transform_data(original_data)
    echo "#{self.class}::#{__callee__}" if @debug

    # Enable dot access to top-level properties (e.g. data.cast_messages)
    data = OpenStruct.new(original_data)

    # ... reserved for future needs ...

    return data
  rescue => e
    echo "*** ERROR MODIFYING DATA IN DEPENDENCY ***"
    echo e.message
    e.backtrace.each { |msg| echo msg }
    OpenStruct.new
  end
end

class MoonWatch
  attr_reader :moon_data

  def initialize(debug)
    @debug = debug
    @moon_data = {}
    UserVars.moons = { 'katamba' => {}, 'yavash' => {}, 'xibar' => {}, 'visible' => [] }
    UserVars.sun = {}
    @firebase_url = 'https://dr-scripts.firebaseio.com/'
    @queue = []
    load_moon_data
  end

  def debug
    @debug = !@debug
  end

  def connections
    return nil unless @debug

    [@f, @moon_source]
  end

  def load_moon_data
    @last_connect = Time.now
    @data_delay = nil
    echo("retrieving moon data") if @debug
    uri = URI.parse("#{@firebase_url}/moon_data_v2.json")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    request = Net::HTTP::Get.new(uri.request_uri)
    request['Content-Type'] = 'application/json'
    response = http.request(request)
    @moon_data = nil if response.body.nil?
    begin
      @moon_data = JSON.parse(response.body.chomp)
    rescue
      @moon_data = nil
    end
  rescue => e
    echo("error in moonwatch #{e.inspect}")
  end

  def queue_update(moon, data)
    @queue << [moon, data]
  end

  def snapshot_seconds_until_load
    return 60 unless UserVars.moons.reject { |m| m == 'visible' }.values.first['timer'] && UserVars.sun['timer']
    return @data_delay if @data_delay

    echo("calculting next moon data request") if @debug
    all_timers = UserVars.moons.reject { |m| m == 'visible' }.values.map { |data| data['timer'] } + [UserVars.sun['timer']]
    @data_delay = ([all_timers.min * 0.8, 1].max * 60).to_i
    echo("Next request in #{@data_delay} seconds") if @debug
    @data_delay
  end

  def run_queue
    load_moon_data if Time.now - @last_connect > snapshot_seconds_until_load
    return if @queue.empty?

    item = @queue.shift
    update_moon(item.first, item.last)
  end

  private

  def update_moon(body_name, data)
    echo("updating #{body_name} with #{data}") if @debug
    uri = URI.parse("#{@firebase_url}/moon_data_v2/#{body_name}.json")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    request = Net::HTTP::Put.new(uri.request_uri)
    request['Content-Type'] = 'application/json'
    request.body = data.to_json
    response = http.request(request)
    response.body.chomp
  end
end

class HornWatch
  def initialize(debug)
    @debug = debug
    @firebase_url = 'https://dr-scripts.firebaseio.com/'
  end

  def debug
    @debug = !@debug
  end

  def submit_horn_update(room, timestamp)
    unless room && timestamp
      echo('Nothing left to submit') if @debug
      return
    end

    echo("submitting:#{room}:#{timestamp}") if @debug
    uri = URI.parse("#{@firebase_url}/egg_warhorn/#{room}.json")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    request = Net::HTTP::Put.new(uri.request_uri)
    request['Content-Type'] = 'application/json'
    request.body = timestamp.to_i.to_json
    response = http.request(request)
    unless response.body
      echo("No response body for some reason. Returning nil.")
      return nil
    else
      response.body.chomp
    end
  end

  def get_horn_data(room)
    echo("retrieving warhorn data for room:#{room}") if @debug
    uri = URI.parse("#{@firebase_url}/egg_warhorn/#{room}.json")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE

    request = Net::HTTP::Get.new(uri.request_uri)
    request['Content-Type'] = 'application/json'
    response = http.request(request)
    return horn_data = Time.at(0) unless response.body

    begin
      return horn_data = Time.at(JSON.parse(response.body.chomp))
    rescue
      return horn_data = Time.at(0)
    end
    echo("warhorn data for room:#{room} is #{horn_data.inspect}") if @debug
  rescue => e
    echo("error in hornwatch #{e.inspect}")
    echo("Returning time.at(0)")
    return Time.at(0)
  end
end

$setupfiles = SetupFiles.new(debug)
$manager = ScriptManager.new(debug)
$bankbot = BankbotManager.new(debug)
$reportbot = ReportbotManager.new(debug)
$slackbot = SlackbotManager.new(debug)
$hornwatch = HornWatch.new(debug)

def enable_moon_connection
  $turn_on_moon_watch = true
end

def get_settings(character_suffixes = [])
  $setupfiles.get_settings(character_suffixes)
end

def get_data(type)
  $setupfiles.get_data(type)
end

def save_bankbot_transaction(transaction, ledger)
  $bankbot.save_bankbot_transaction(transaction, ledger)
end

def load_bankbot_ledger
  $bankbot.load_bankbot_ledger
  pause 0.1 until $bankbot.loaded?
  $bankbot.ledger
end

def save_reportbot_whitelist(whitelist)
  $reportbot.save_reportbot_whitelist(whitelist)
end

def load_reportbot_whitelist
  $reportbot.load_reportbot_whitelist
  pause 0.1 until $reportbot.loaded?
  $reportbot.whitelist
end

def send_slackbot_message(message)
  $slackbot.queue_message(message)
end

def register_slackbot(username)
  $slackbot.register(username)
end

def format_name(name)
  name =~ /\.lic$/ ? name : "#{name}.lic"
end

def format_yaml_name(name)
  name =~ /\.yaml$/ ? name : "#{name}.yaml"
end

def custom_require
  lambda do |script_names|
    script_names = [script_names] unless script_names.is_a?(Array)
    respond("CR:starting:#{script_names}") if UserVars.bootstrap_debug
    bootstrapper = force_start_script('bootstrap', script_names)
    pause 0.05
    while Script.running.include?(bootstrapper)
      respond("CR:waiting:#{script_names}") if UserVars.bootstrap_debug
      pause 0.05
    end
    respond("CR:done:#{script_names}") if UserVars.bootstrap_debug
  end
end

def verify_script(script_names)
  script_names = [script_names] unless script_names.is_a?(Array)
  state = true
  script_names
    .reject { |name| Script.exists?(name) }
    .each do |name|
      echo "Failed to find a script named '#{name}'"
      echo "Please report this to <https://github.com/rpherbig/dr-scripts/issues>"
      echo "or to Discord <https://discord.gg/3UMbxypN>"
      state = false
    end
  state
end

def get_script(script_name)
  $manager.get_script(format_name(script_name), true)
end

def force_refresh_scripts
  $manager.start_scripts
end

def list_tracked_scripts
  $manager.get_versions.sort
end

def full_install
  if !supported_ruby_version?
    echo "You are using an unsupported version of ruby."
    echo "In order to prevent people from wasting too much work on an unsupported version, this will not proceed."
    echo "Please update to at least version #{$MIN_RUBY_VERSION} and try again."
    echo "For further details / assistance, please join the dr-scripts Lich Discord: https://discord.gg/uxZWxuX "
    exitfrom
  end
  respond 'Performing setup for dr-scripts.  This will take some time.  Do not stop this script until finished.'
  respond '(Step 1 of 5) Removing lich autostarts for existing scripts...'
  remove_from_autostart(managed_scripts)
  respond '(Step 2 of 5) Adding dependency.lic to lich autostart'
  add_self_to_autostart
  respond '(Step 3 of 5) Creating a /profiles directory and downloading default profiles (this will take a while)'
  setup_profiles
  respond '(Step 4 of 5) Creating a /data directory and downloading data files (this will take a while)'
  setup_data
  respond '(Step 5 of 5) Backing up existing scripts and replacing with latest versions (this will take a while)'
  replace_all
  respond 'Finished install!'
end

def replace_all
  managed_scripts
    .each do |script|
      new_name = "#{script}.#{Time.now.to_i}.bak"
      respond "Renaming existing script #{script} to #{new_name}"
      File.rename(File.join(SCRIPT_DIR, "#{script}"), File.join(SCRIPT_DIR, "#{new_name}"))
    end

  respond "Downloading all scripts (This may take a few minutes. Please wait until you see \"Finished Install\" before doing anything else"
  $manager.repo_scripts.each(&method(:get_script))
end

def managed_scripts
  local_scripts = Dir[File.join(SCRIPT_DIR, '*.lic')].map { |item| File.basename(item) }
  $manager.repo_scripts & local_scripts
end

def list_autostarts
  $manager.autostarts
end

def autostart(script_names, global = true)
  script_names = [script_names] unless script_names.is_a?(Array)
  script_names.map!(&method(:format_name))
  if global
    script_names.each { |script| $manager.add_global_auto(script) }
  else
    script_names.each { |script| UserVars.autostart_scripts.push(script) unless UserVars.autostart_scripts.include?(script) }
  end
  script_names.each { |script| $manager.run_script(script) }
end

def stop_autostart(script_names)
  script_names = [script_names] unless script_names.is_a?(Array)

  script_names.each do |script|
    if UserVars.autostart_scripts.include?(script)
      UserVars.autostart_scripts.delete(script)
    else
      $manager.remove_global_auto(script)
    end
  end
end

def set_custom_status_repo(repo, branch = 'master')
  $manager.set_custom_status_repo(repo, branch)
end

def set_custom_status_branch(branch)
  $manager.set_custom_status_branch(branch)
end

def unset_custom_status
  $manager.unset_custom_status
end

def check_custom_status
  echo $manager.check_custom_status
end

def setup_profiles
  $manager.setup_profiles
end

def setup_data
  $manager.setup_data
end

def supported_ruby_version?
  return Gem::Version.new(RUBY_VERSION) >= Gem::Version.new($MIN_RUBY_VERSION)
end

def validate_supported_ruby_version
  # Get stored time for next check (or now if not stored yet)
  next_check_datetime = CharSettings['next_ruby_version_check_datetime'] || Time.now

  # Don't spam user every iteration of run_queue
  return if next_check_datetime > Time.now

  # Check for supported version
  if !supported_ruby_version?
    echo "*** WARN WARN WARN WARN WARN WARN WARN ***"
    echo "WARN: You are using an unsupported version of ruby."
    echo "WARN: While many scripts may still continue to run, there are some that may not."
    echo "WARN: Please update to at least version #{$MIN_RUBY_VERSION} as soon as possible."
    echo "WARN: For further details / assistance, please join the dr-scripts Lich Discord: https://discord.gg/uxZWxuX."
    echo "WARN: This warning will repeat on startup and every three hours."
    echo "*** WARN WARN WARN WARN WARN WARN WARN ***"
  end

  # Set next check time to 3 hours from now
  CharSettings['next_ruby_version_check_datetime'] = Time.now + (60 * 60 * 3)
end

def remove_from_autostart(scripts)
  return if Script.running?('autostart')

  scripts.each do |script|
    start_script('autostart', ['remove', '--global', File.basename(script, '.*')])
    pause 0.1 while Script.running?('autostart')
    start_script('autostart', ['remove', File.basename(script, '.*')])
    pause 0.1 while Script.running?('autostart')
  end
end

def add_self_to_autostart
  return if Script.running?('autostart')

  start_script('autostart', ['add', '--global', 'dependency'])
  pause while Script.running?('autostart')
end

def update_d
  echo('Restarting Dependency in 2 seconds...')
  force_start_script('bootstrap', ['wipe_constants'])
  before_dying do
    sleep 2
    force_start_script('dependency')
  end
  stop_script('drinfomon') if Script.running?('drinfomon')
  stop_script('dependency')
end

def submit_thieving_update(id, update)
  $manager.queue_thieving_update(id, update)
end

def submit_shop_data(shop_data)
  $manager.queue_shop_update(shop_data)
end

def get_all_moon_data
  $moon_watch ? $moon_watch.moon_data : nil
end

def update_moon_data(moon, data)
  $moon_watch.queue_update(moon, data)
end

def shift_hometown(town_name)
  $HOMETOWN = town_name
end

def clear_hometown
  $HOMETOWN = nil
end

def warn_custom_scripts
  custom_scripts = Dir.entries(File.join(SCRIPT_DIR, 'custom')).reject { |f| File.directory?(f) || File.basename(f).start_with?(".") }
  curated_scripts = Dir.entries(SCRIPT_DIR).reject { |f| File.directory?(f) || File.basename(f).start_with?(".") }
  include_list = []

  custom_scripts.each do |script|
    include_list.push(script) if curated_scripts.include?(script)
  end

  unless include_list.empty?
    echo "NOTE: The following curated scripts are in your custom folder and will not receive updates"
    echo "#{include_list}" unless include_list.empty?
  end
end

full_install if install

force_start_script('bootstrap', ['wipe_constants'])

# Proactively starting DRinfomon as script zero to prevent
# race conditions involving this script which so many other
# scripts depend on, and which is slow to start on its own
echo("Starting DRinfomon, this will take a few seconds.")
custom_require.call('drinfomon')
echo("DRinfomon ready.")

$manager.check_base_files
$manager.check_data_files
$manager.start_scripts
$manager.make_map_edits

if $manager.updated_dependency?
  echo('Update found for dependency.lic')
  update_d
end

before_dying do
  $moon_watch = nil
  stop_script('drinfomon') if Script.running?('drinfomon')
end

$setupfiles.reload

# Remind user of curated scripts with a copy in custom folder
warn_custom_scripts

loop do
  if $turn_on_moon_watch && $moon_watch.nil?
    $moon_watch = MoonWatch.new(debug)
    $turn_on_moon_watch = nil
  end

  $manager.run_queue
  $bankbot.run_queue
  $reportbot.run_queue
  $slackbot.run_queue
  $moon_watch.run_queue if $moon_watch
  clear
  pause 0.1
end