validate.lic

custom_require.call(['drinfomon'])

class DRYamlValidator
  def initialize
    arg_definitions = [[
      { name: 'verbose', regex: /verbose/i, optional: true }
    ]]

    args = parse_args(arg_definitions, true)

    @warning_count = 0
    @error_count = 0

    settings = get_settings(args.flex)
    assertions = DRYamlValidator.instance_methods.select { |x| x.to_s =~ /^assert_that_/ && DRYamlValidator.instance_method(x).arity == 1 }

    setup_data

    if settings.hunting_file_list
      respond("  Validating settings for #{settings.hunting_file_list.size} settings files")
      settings.hunting_file_list.each do |file|
        respond("  Checking #{assertions.size} different potential errors in file #{checkname}-#{file}.yaml")
        settings_set = file == 'setup' ? get_settings : get_settings([file])
        assertions.each do |symbol|
          if args.verbose
            respond("  #{symbol}")
            @test_symbol = symbol
          end
          send(symbol, settings_set)
        end
      end
    else
      respond("  Checking #{assertions.size} different potential errors")
      assertions.each do |symbol|
        if args.verbose
          respond("  #{symbol}")
          @test_symbol = symbol
        end
        send(symbol, settings)
      end
    end

    respond("  WARNINGS:#{@warning_count} ERRORS:#{@error_count}")
    respond('  All done!')
  end

  def assert_that_root_keys_exist(settings)
    %w[weapon_training crossing_training hunting_info gear gear_sets]
      .select { |key| settings[key].nil? }
      .each { |key| warn("You are missing a setting that is probably needed: #{key}") }
  end

  def assert_that_weapon_training_has_skills(settings)
    return unless settings.weapon_training && settings.weapon_training.empty?

    warn('You have no weapons configured in weapon_training: this will likely cause problems.')
  end

  def assert_that_appraisal_training_settings_are_valid(settings)
    return if settings.appraisal_training.empty?
    valid_settings = %w[pouches zills art gear bundle]
    bad_settings = settings.appraisal_training - valid_settings
    return if bad_settings.nil? || bad_settings.empty?

    warn("You have the following invalid appraisal_training settings: #{bad_settings}\nValid appraisal_training settings are: #{valid_settings}")
  end

  def assert_that_pouch_appraisal_has_defined_container(settings)
    return unless settings.appraisal_training.include?('pouches')
    return if settings.full_pouch_container

    warn('Must have full_pouch_container defined if training appraisal with pouches')
  end

  def assert_that_empty_pouch_container_is_different_than_full_pouch_container(settings)
    return unless settings.full_pouch_container
    return unless settings.full_pouch_container == settings.spare_gem_pouch_container

    warn('Full pouch container cannot be the same as the spare pouch container')
  end

  def assert_that_aspects_are_neutral_if_not_using_altars(settings)
    return if settings.use_favor_altars
    return if @neutral_aspects.include?(settings.favor_god.capitalize)

    error("The favor_god: #{settings.favor_god} you have set requires use_favor_altars: true, only neutral aspects can use the puzzle for orbs")
  end

  def assert_that_water_holder_is_set_when_using_altars(settings)
    return unless settings.use_favor_altars
    return if settings.water_holder

    error('water_holder: must be defined in your yaml to use favor_altars. ex: water_holder: chalice')
  end

  def assert_that_weapon_training_are_skills(settings)
    return unless settings.weapon_training

    settings.weapon_training
            .keys
            .reject { |skill_name| @valid_weapon_skills.include?(skill_name) }
            .each { |skill_name| error("Invalid weapon_training: skill name '#{skill_name}'. Valid skills are '#{@valid_weapon_skills}'") }
  end

  def assert_that_dance_skill_is_skill(settings)
    return unless settings.dance_skill

    error("dance_skill: skill name '#{settings.dance_skill}' is not valid. Valid skills are '#{@valid_melee_skills}'") unless @valid_melee_skills.include?(settings.dance_skill)
  end

  def assert_that_priority_weapons_are_skills(settings)
    return unless settings.priority_weapons

    settings.priority_weapons
            .reject { |skill_name| @valid_weapon_skills.include?(skill_name) }
            .each { |skill_name| error("Invalid priority_weapons: skill name '#{skill_name}'. Valid skills are '#{@valid_weapon_skills}'") }
  end

  def assert_that_combat_spell_training_spells_are_skills(settings)
    return unless settings.combat_spell_training

    valid_combat_spell_training_skills = %w[Augmentation Sorcery Utility Warding]

    settings.combat_spell_training
            .keys
            .reject { |skill_name| valid_combat_spell_training_skills.include?(skill_name) }
            .each { |skill_name| error("Invalid combat_spell_training: skill name '#{skill_name}'. Valid skill names are '#{valid_combat_spell_training_skills}'") }
  end

  def assert_that_crafting_training_spells_are_skills(settings)
    return unless settings.crafting_training_spells

    valid_crafting_training_spells_skills = %w[Augmentation Utility Warding]

    settings.crafting_training_spells
            .keys
            .reject { |skill_name| valid_crafting_training_spells_skills.include?(skill_name) }
            .each { |skill_name| error("Invalid crafting_training_spells: skill name '#{skill_name}'. Valid skill names are '#{valid_crafting_training_spells_skills}'") }
  end

  def assert_that_crafting_training_spells_have_no_cambrinth(settings)
    return unless settings.crafting_training_spells

    settings.crafting_training_spells.select { |_spell, data| data['cambrinth'] }
            .each_key { |spell| warn("#{spell} in crafting_training_spells uses cambrinth which increases crafting time, you may want to remove it.") }
  end

  def assert_that_cycle_armors_are_skills(settings)
    return unless settings.cycle_armors

    settings.cycle_armors
            .reject { |skill| ['Light Armor', 'Chain Armor', 'Brigandine', 'Plate Armor'].include?(skill) }
            .each_key { |skill| error("Skill name in cycle_armors is not valid: #{skill}") }
  end

  def assert_that_summoned_weapons_are_skills(settings)
    return unless settings.summoned_weapons

    settings.summoned_weapons
            .reject { |info| @valid_summon_skills.include?(info['name']) }
            .each { |info| error("Invalid summoned_weapons: skill name '#{info['name']}'") }
  end

  def assert_that_summoned_weapons_are_in_weapon_training(settings)
    return unless settings.summoned_weapons
    return unless settings.weapon_training

    settings.summoned_weapons
            .reject { |info| settings.weapon_training.keys.include?(info['name']) }
            .each { |info| warn("A summoned_weapons: skill name '#{info['name']}' is not in weapon_training:") }
  end

  def assert_that_stop_on_skills_are_valid(settings)
    return unless settings.hunting_info

    settings.hunting_info
            .reject { |info| info['stop_on'].nil? }
            .reject { |info| (info['stop_on'] - @all_skills).empty? }
            .each { |info| error("stop_on: skills not recognized as valid skills '#{(info['stop_on'] - @all_skills)}'") }
  end

  def assert_that_stop_on_weapon_skills_are_in_weapon_training(settings)
    return unless settings.hunting_info
    return unless settings.weapon_training

    settings.hunting_info
            .reject { |info| info['stop_on'].nil? }
            .map { |info| info['stop_on'] }
            .flatten
            .uniq
            .reject { |skill| settings.weapon_training.keys.include?(skill) }
            .select { |skill| @valid_weapon_skills.include?(skill) }
            .each { |skill| error("stop_on: weapon skill #{skill} not in weapon_training: setting") }
  end

  def assert_that_hunting_info_has_duration_or_stop_on(settings)
    return unless settings.hunting_info

    settings.hunting_info
            .select { |info| info[:duration].nil? }
            .select { |info| info['stop_on'].nil? }
            .each { |info| error("Must have at least one of :duration or stop_on for hunting_info '#{info[:zone]}'") }
  end

  def assert_that_priority_skills_exists_if_hunting_priority(settings)
    return unless settings.training_manager_hunting_priority
    return unless settings.training_manager_priority_skills.empty?

    error('training_manager_hunting_priority is true, but no training_manager_priority_skills were set')
  end

  def assert_that_priority_skills_skills_are_valid(settings)
    return unless settings.hunting_info
    return unless settings.training_manager_priority_skills

    settings.training_manager_priority_skills
            .reject { |skill| @all_skills.include?(skill) }
            .each { |skill| error("Invalid training_manager_priority_skills: skill name '#{skill}'") }
  end

  def assert_that_priority_defense_skill_is_valid(settings)
    return unless settings.priority_defense

    error("Invalid priority_defense skill: skill name '#{settings.priority_defense}'") unless @valid_defensive_skills.include?(settings.priority_defense)
  end

  def assert_that_hunting_info_has_zones(settings)
    return unless settings.hunting_info

    settings.hunting_info
            .reject { |info| info[:zone] }
            .each_with_index { |_info, index| error("Hunting info at index '#{index}' had no zone.") }
  end

  def assert_that_hunting_info_zones_are_in_hunting_or_escort_zones(settings)
    return unless settings.hunting_info

    hunting_zones = get_data('hunting').hunting_zones
    escort_zones = get_data('hunting').escort_zones

    zone_names = []
    settings.hunting_info
            .select { |info| info[:zone] }
            .each { |name| zone_names.push(*name[:zone]) }
    zone_names
      .reject { |name| !hunting_zones.nil? && hunting_zones.include?(name) }
      .reject { |name| !escort_zones.nil? && escort_zones.include?(name) }
      .each { |name| error("Hunting zone not found in hunting_zones or escort_zones. '#{name}'") }
  end

  def assert_that_gear_sets_not_nil(settings)
    return unless settings.gear_sets

    settings.gear_sets
            .select { |_name, items| items.nil? }
            .each_key { |name| error("gear_set: '#{name}' is nil, an empty gear set should be #{name}: []") }
  end

  def assert_that_gear_sets_has_standard(settings)
    return unless settings.gear_sets
    return if settings.gear_sets['standard']

    warn('a \'standard\' gear_set: entry is required for combat-trainer to function.')
  end

  def assert_that_gear_sets_has_stealing_if_training_thievery(settings)
    return unless settings.gear_sets
    return unless settings.crossing_training && settings.crossing_training.include?('Thievery')
    return if settings.gear_sets['stealing']

    warn('a \'stealing\' gear_set: entry is required when training Thievery.')
  end

  def assert_that_crafting_magic_exist_if_crafting_and_caster(settings)
    return if settings.crafting_training_spells
    return unless settings.crossing_training
    return if DRStats.thief? || DRStats.barbarian?

    settings.crossing_training
            .select { |skill| %w[Outfitting Forging Alchemy Engineering].include?(skill) }
            .each { |skill| warn("You are a magic user and have #{skill} in crossing_training but do not have crafting_training_spells set up. You may want to consider adding it.") }
  end

  def assert_that_not_feinting_with_offhand(settings)
    return unless settings.dance_skill == 'Offhand Weapon'
    return unless settings.dance_actions.grep(/feint/i) || settings.dance_actions_stealth.grep(/feint/i)

    error('Feint in your actions list will cause an error when Offhand Weapon is your dance skill')
  end

  def assert_that_no_research_only_skills_if_research_is_off(settings)
    return if settings.use_research
    return unless settings.crossing_training

    settings.crossing_training
            .select { |skill| ['Life Magic', 'Holy Magic', 'Lunar Magic', 'Elemental Magic', 'Arcane Magic'].include?(skill) }
            .each { |skill| error("You have a research only skill '#{skill}' listed in crossing_training but research is disabled") }
  end

  def assert_that_all_research_skills_are_in_crossing_training(settings)
    return unless settings.use_research
    return unless settings.crossing_training
    return unless settings.research_skills

    settings.research_skills
            .reject { |skill| settings.crossing_training.include?(skill) }
            .each { |skill| error("Skill in research_skills could not be found in crossing_training. '#{skill}'") }
  end

  def assert_that_all_research_skills_are_valid(settings)
    return unless settings.use_research
    return unless settings.crossing_training
    return unless settings.research_skills

    settings.research_skills
            .reject { |skill| @valid_research_skills.include?(skill) }
            .each { |skill| error("Skill in research_skills was not a valid research skill. '#{skill}'") }
  end

  def assert_that_crossing_training_skills_are_valid(settings)
    return unless settings.crossing_training

    settings.crossing_training
            .reject { |skill| @all_skills.include?(skill) }
            .each { |skill| error("Invalid crossing_training: skill name '#{skill}'") }
  end

  def assert_that_crossing_training_requires_movement_skills_are_valid(settings)
    return unless settings.crossing_training_requires_movement

    settings.crossing_training_requires_movement
            .reject { |skill| @all_skills.include?(skill) }
            .each { |skill| error("Invalid crossing_training_requires_movement: skill name '#{skill}'") }
  end

  def assert_that_train_workorders_are_valid(settings)
    return unless settings.train_workorders

    settings.train_workorders
            .reject { |discipline| %w[Blacksmithing Tailoring Carving Shaping Remedies].include?(discipline) }
            .each { |discipline| error("Invalid train_workorders: discipline name '#{discipline}'") }
  end

  def assert_that_mines_to_mine_are_in_mining_buddy_rooms(settings)
    return unless settings.mines_to_mine

    mining_rooms = get_data('mining').mining_buddy_rooms
    settings.mines_to_mine
            .reject { |mine| mining_rooms.include?(mine) }
            .each { |mine| error("Mine in mines_to_mine could not be found in mining_buddy_rooms. '#{mine}'") }
  end

  def assert_that_gear_sets_contain_described_items(settings)
    return unless settings.gear_sets

    settings.gear_sets
            .values
            .flatten
            .uniq
            .reject { |item| settings.gear.find { |data| item =~ /#{data[:adjective]}\s*#{data[:name]}/i } }
            .each { |item| error("Item in gear_set could not be found in gear listings. '#{item}'") }
  end

  def assert_that_weapon_training_weapons_in_gear(settings)
    return unless settings.weapon_training

    settings.weapon_training
            .reject { |_skill, item| item.empty? }
            .reject { |_skill, item| settings.gear.find { |data| item =~ /#{data[:adjective]}\s*#{data[:name]}/i } }
            .reject { |skill, _item| settings.summoned_weapons && settings.summoned_weapons.find { |data| data['name'] == skill } }
            .each { |skill, item| error("Item in weapon_training could not be found in gear listings. '#{skill}: #{item}'") }
  end

  def assert_minimum_whirlwind_trainables(settings)
    return unless settings.whirlwind_trainables
    return unless settings.whirlwind_trainables.count < 2

    error('Whirlwinding requires a minimum of two one-handed template weapons!')
  end

  def assert_that_whirlwind_trainables_are_one_handed(settings)
    return unless settings.whirlwind_trainables
    return unless settings.whirlwind_trainables.include?('Twohanded Blunt') || settings.whirlwind_trainables.include?('Twohanded Edged')

    error('Whirlwind does not support twohanded weapons at this time. We only support one-handed weapon templates.')
  end

  def assert_that_whirlwind_trainables_are_in_weapon_training(settings)
    return unless settings.weapon_training && settings.whirlwind_trainables

    settings.whirlwind_trainables
            .select { |desc| settings.weapon_training.value?(desc) }
            .each { |desc| error("Weapon skill '#{desc}' not found in weapon_training! All whirlwind_trainables need to also be listed in weapon_training.") }
  end

  def assert_that_whirlwind_trainables_are_not_swappables(settings)
    return if settings.whirlwind_trainables.nil? || settings.whirlwind_trainables.empty?

    settings.whirlwind_trainables.each do |weapon|
      desc = settings.weapon_training[weapon]
      gear_data = settings.gear.find { |data| desc =~ /#{data[:adjective]}\s*#{data[:name]}/i }
      if gear_data[:swappable]
        error("The listed weapon, #{desc}, is a swappable! We don't support the use of swappable weapons during whirlwind training. The overhead of swapping back and forth was found to be cumbersome and time consuming.")
      end
    end
  end

  def assert_that_training_abilities_are_valid(settings)
    return unless settings.training_abilities

    settings.training_abilities
            .reject { |skill, _cooldown| ['PercMana', 'Perc', 'Perc Health', 'Astro', 'App', 'App Quick', 'App Careful', 'Tactics', 'Hunt', 'Pray', 'Scream', 'Khri Prowess', 'Stealth', 'Ambush Stun', 'Ambush Choke', 'Favor Orb', 'Charged Maneuver', 'Meraud', 'Recall', 'Barb Research Debilitation', 'Barb Research Augmentation', 'Barb Research Warding', 'Collect', 'Analyze', 'PrayerMat', 'Smite', 'Locks', 'Teach'].include?(skill) }
            .each_key { |skill| error("Ability in training_abilities is not valid: #{skill}") }
  end

  def assert_that_pet_source_is_defined_for_locks(settings)
    return unless settings.training_abilities['Locks']
    return if settings.picking_pet_box_source

    error('You must have a picking_pet_box_source: to use Locks in training_abilities')
  end

  def assert_that_dance_skill_in_weapon_training(settings)
    return unless settings.weapon_training
    return unless settings.dance_skill
    return if settings.weapon_training[settings.dance_skill]

    error("Dance skill '#{settings.dance_skill}' must be in weapon_training")
  end

  def assert_that_necro_ritual_is_valid(settings)
    return unless settings.thanatology
    return unless settings.thanatology['ritual_type']
    return if %w[preserve harvest fetish cut dissect consume arise cycle].include?(settings.thanatology['ritual_type'])

    error("thanatology['ritual_type']: '#{settings.thanatology['ritual_type']}' is invalid, only [preserve, harvest, fetish, cut, dissect, consume, arise, and cycle] are supported at this time.")
  end

  def assert_that_safe_room_necro_has_valid_container(settings)
    return unless settings.necro_safe_room_use_material
    return if settings.necromancer_healing['Devour'] && settings.thanatology['harvest_container']

    error('Safe room necromancer healing requires the use of devour listed under necromancer_healing and a harvest_container listed under thanatology.')
  end

  def assert_that_safe_room_necro_is_storing_material(settings)
    return unless settings.necro_safe_room_use_material
    return unless settings.necromancer_healing['Devour'] && settings.thanatology['store'] == false

    error('Safe room necromancer healing requires material on hand to use. You are not storing material and will eventually run out. This needs to be true to be fully functional, long term.')
  end

  def assert_that_cyclic_training_spells_are_defined(settings)
    return unless settings.cyclic_cycle_skills

    settings.cyclic_cycle_skills
            .reject { |skill| settings.cyclic_training_spells.include? skill }
            .each { |skill| error("Skill in cyclic_cycle_skills does not have a cyclic_training_spell defined: #{skill}") }
  end

  def assert_that_crossing_training_spells_are_defined(settings)
    return unless settings.crossing_training
    return unless settings.train_with_spells

    %w[Augmentation Warding Utility Debilitation]
      .select { |skill| settings.crossing_training.include? skill }
      .reject { |skill| settings.training_spells.include? skill }
      .each { |skill| error("Magic skill in crossing_training does not have a training_spells defined: #{skill}") }
  end

  def assert_that_crossing_training_nonspells_are_defined(settings)
    return unless settings.crossing_training
    return if settings.train_with_spells

    %w[Augmentation Warding Utility Debilitation]
      .select { |skill| settings.crossing_training.include? skill }
      .reject { |skill| settings.training_nonspells.include? skill }
      .each { |skill| error("Magic skill in crossing_training does not have a training_nonspells defined: #{skill}") }
  end

  def assert_that_is_empath_is_deprecated(settings)
    return unless settings.is_empath

    warn('The is_empath setting is deprecated and can be removed from your YAML. We now check your guild from the info command.')
  end

  def assert_that_appraise_pouches_is_deprecated(settings)
    return unless settings.train_appraisal_with_pouches

    warn('***YOU HAVE OUTDATED SETTINGS*** THE SETTING train_appraisal_with_pouches IS NO LONGER USED. READ MORE HERE: https://elanthipedia.play.net/Lich_script_repository#appraisal')
  end

  def assert_that_appraise_gear_is_deprecated(settings)
    return unless settings.train_appraisal_with_gear

    warn('***YOU HAVE OUTDATED SETTINGS*** THE SETTING train_appraisal_with_gear IS NO LONGER USED. READ MORE HERE: https://elanthipedia.play.net/Lich_script_repository#appraisal')
  end

  def assert_that_tailoring_belt_is_deprecated(settings)
    return unless settings.tailoring_belt

    warn('The tailoring_belt setting is deprecated and can be removed from your YAML. The outfitting_belt setting should be used instead.')
  end

  def assert_that_astrology_buffs_is_deprecated(settings)
    return unless settings.astrology_buffs && settings.astrology_buffs['spells']

    warn('*** YOU HAVE OUTDATED SETTINGS *** THE SETTING astrology_buffs[spells] IS NO LONGER USED. Astrology buffs now uses a waggle set named astrology!')
  end

  def assert_that_crossing_training_sorcery_as_string_is_deprecated(settings)
    return unless settings.crossing_training_sorcery
    return unless settings.crossing_training_sorcery.is_a?(String)

    warn('The crossing_training_sorcery setting should not be a string. Instead it should be a spell definition similar to astrology_buffs, lockpick_buffs, scouting_buffs, or stealing_buffs.')
  end

  def assert_that_weapon_training_has_ranged_skill_when_retreat_is_enabled(settings)
    return unless settings.hunting_info
    return unless settings.weapon_training
    return if (@valid_ranged_skills & settings.weapon_training.keys).any?

    settings.hunting_info
            .select { |info| (info['args'] || []).any? { |arg| arg =~ /r\d+/ } }
            .each { |info| error("Hunt '#{info[:zone]}' has a retreat threshold set, but no ranged weapon skills to train. You may get stuck retreating and not training any weapons because enemies will not be attacked.") }
  end

  def assert_that_barb_buffs_are_in_base_spells(settings)
    return unless settings.buff_nonspells
    return unless settings.buff_nonspells['barb_buffs']

    supported_buffs = get_data('spells').barb_abilities

    settings.buff_nonspells['barb_buffs']
            .reject { |name| supported_buffs.include?(name) }
            .each { |name| error("Barb ability '#{name}' not yet supported. Please make an issue on Github (https://github.com/rpherbig/dr-scripts/issues) for it to be added!") }
  end

  def assert_that_predict_event_is_deprecated(settings)
    return unless settings.predict_event

    warn('***YOU HAVE OUTDATED SETTINGS*** THE SETTING predict_event IS NO LONGER USED. READ MORE HERE: https://elanthipedia.play.net/Lich_script_repository#astrology')
  end

  def assert_that_train_in_ap_is_deprecated(settings)
    return unless settings.astral_plane_training['train_in_ap']

    warn('***YOU HAVE OUTDATED SETTINGS*** THE SETTING train_in_ap IS NO LONGER USED. READ MORE HERE: https://elanthipedia.play.net/Lich_script_repository#astrology')
  end

  def assert_that_astrology_keys_are_valid(settings)
    return unless settings.astrology_training
    settings.astrology_training
            .reject { |key| @valid_astrology_keys.include?(key) }
            .each { |key| error("Astrology does not have a method for '#{key}'! Valid keys are '#{@valid_astrology_keys.join(', ')}'") }
  end

  def assert_that_necro_train_first_aid_is_deprecated(settings)
    return unless settings.thanatology
    return unless settings.thanatology['train_first_aid']

    warn('***YOU HAVE OUTDATED SETTINGS*** THE SETTING thanatology["train_first_aid"] IS NO LONGER USED. To train first aid via rituals use the dissect ritual (thanatology["ritual_type"]=dissect) or cycle rituals (thanatology["ritual_type"]=cycle).')
  end

  def assert_that_hometown_is_valid(settings)
    return unless settings.hometown

    valid_hometowns = get_data('town')
                      .to_h
                      .keys
                      .map(&:to_s)

    return if valid_hometowns.include? settings.hometown
    warn("Your hometown of '#{settings.hometown}' is not valid. Valid values are: #{valid_hometowns}")
  end

  def assert_that_force_healer_town_is_valid(settings)
    return unless settings.force_healer_town

    valid_hometowns = get_data('town')
                      .to_h
                      .keys
                      .map(&:to_s)

    return if valid_hometowns.include? settings.force_healer_town
    error("Your force_healer_town setting of '#{settings.force_healer_town}' is not valid. Valid values are: #{valid_hometowns}")
  end

  def assert_that_hometown_has_npc_empath(settings)
    town_data = get_data('town')
    hometown = town_data[settings.force_healer_town || settings.hometown]
    return unless hometown && hometown['npc_empath'].nil?
    error('No npc empath exists in your hometown or force_healer_town so healing will not work, please pick another town.')
  end

  def assert_that_lockpick_buffs_are_deprecated(settings)
    return if !settings.lockpick_buffs || settings.lockpick_buffs.empty?

    warn('***YOU HAVE OUTDATED SETTINGS*** THE SETTING lockpick_buffs IS NO LONGER USED. Please make a waggle_set called \'pick\'')
  end

  def assert_that_sell_loot_money_on_hand_is_correct(settings)
    settings.sell_loot_money_on_hand =~ /(\d+) (\w+)/
    amount = Regexp.last_match(1)
    denomination = Regexp.last_match(2)
    return if amount && %w[copper bronze silver gold platinum].any? { |denom| denom[/^#{denomination}/] }
    error('sell_loot_money_on_hand is invalid. The proper format is: <amount> <denomination> e.g. 3 silv or 4 bronze')
  end

  def assert_that_pet_buffs_have_spell_requirements(settings)
    return unless settings.buff_spells

    settings.buff_spells.select { |_name, data| data['pet_type'] }
            .reject { |_name, data| data.include? 'recast_every' }
            .each_key { |name| error("Pet buffs require a custom recast timer. Please include a \"recast_every:\" setting for #{name}.") }

    settings.buff_spells.select { |_name, data| data['pet_type'] }
            .reject { |_name, data| data.include? 'cast' }
            .each_key { |name| error("Pet buffs require a custom cast message. Please include a \"cast:\" setting for #{name}.") }
  end

  def assert_that_restock_shop_items_recipes_are_valid(settings)
    return if settings.restock_shop.empty?
    return unless settings.restock_shop.key?('items')

    recipes = get_data('recipes').crafting_recipes
    unknown_item_recipes = settings.restock_shop['items'].reject { |item| recipes.any? { |recipe| recipe['name'].match(item['recipe']) } }
    return if unknown_item_recipes.empty?
    error("The following restock shop items match no recipe data: #{unknown_item_recipes.map { |item| item['recipe'] }}")
  end

  def assert_that_workorder_cash_on_hand_is_correct(settings)
    return unless settings.workorder_cash_on_hand
    return if settings.workorder_cash_on_hand.is_a?(Integer)

    error('workorder_cash_on_hand is invalid. The proper format is 5000 for 5 gold for example')
  end

  def assert_that_repair_withdrawal_amount_is_correct(settings)
    return unless settings.repair_withdrawal_amount
    return if settings.repair_withdrawal_amount.is_a?(Integer)

    error('repair_withdrawal_amount: is invalid. The proper format is 5000 for 5 gold for example')
  end

  def assert_that_regalia_waggle_is_defined(settings)
    return unless settings.cycle_armors_regalia
    return if settings.waggle_sets['regalia']['Regalia']

    warn("No Regalia waggle defined. Combat-trainer will use min prep unless you declare a waggle named 'regalia' with different values")
  end

  def assert_that_regalia_waggle_has_abbrev(settings)
    return unless settings.cycle_armors_regalia
    return if settings.waggle_sets['regalia']['Regalia']['abbrev'].casecmp('REGAL').zero?

    error("Regalia waggle's abbreviation differs from default. Change to abbrev: REGAL")
  end

  def assert_that_regalia_gearset_is_defined(settings)
    return unless settings.cycle_armors_regalia
    return unless settings.gear_sets['regalia'].empty? || settings.gear_sets['regalia'].nil?

    error("Regalia cycling requires a gear_set named 'regalia' that is missing any armor you wish Regalia to replace.")
  end

  def assert_that_regalia_does_not_conflict_with_armor_swap(settings)
    return unless settings.cycle_armors && settings.cycle_armors_regalia

    error('cycle_armors and cycle_armors_regalia at the same time not currently supported! Combat-trainer will default to cycle_armors only!')
  end

  def assert_that_cycle_regalia_are_skills(settings)
    return unless settings.cycle_armors_regalia

    settings.cycle_armors_regalia
            .reject { |skill| ['Light Armor', 'Chain Armor', 'Brigandine', 'Plate Armor'].include?(skill) }
            .any? { |skill| error("Skill name in cycle_armors_regalia is not valid: #{skill}") }
  end

  private

  def warn(message)
    echo(@test_symbol) if @test_symbol
    echo("WARNING:< #{message}  >")
    @warning_count += 1
  end

  def error(message)
    echo(@test_symbol) if @test_symbol
    echo("ERROR:< #{message}  >")
    @error_count += 1
  end

  def setup_data
    @valid_astrology_keys = %w[ways observe rtr weather events attunement]
    @valid_thrown_skills = ['Heavy Thrown', 'Light Thrown']
    @valid_aimed_skills = %w[Bow Slings Crossbow]
    @valid_ranged_skills = @valid_thrown_skills + @valid_aimed_skills
    @valid_melee_skills = ['Offhand Weapon', 'Brawling', 'Polearms', 'Large Blunt', 'Twohanded Blunt', 'Staves', 'Small Blunt', 'Small Edged', 'Large Edged', 'Twohanded Edged']
    @valid_weapon_skills = @valid_ranged_skills + @valid_melee_skills + ['Targeted Magic']
    @valid_summon_skills = @valid_thrown_skills + @valid_melee_skills - ['Offhand Weapon', 'Brawling']
    @valid_research_skills = ['Arcana', 'Life Magic', 'Holy Magic', 'Lunar Magic', 'Elemental Magic', 'Arcane Magic', 'Attunement', 'Warding', 'Augmentation', 'Utility']
    @valid_defensive_skills = ['Shield Usage', 'Parry Ability', 'Evasion']

    @all_skills = ['Scouting', 'Evasion', 'Athletics', 'Stealth', 'Perception', 'Locksmithing', 'First Aid', 'Skinning',
                   'Outdoorsmanship', 'Thievery', 'Backstab', 'Thanatology', 'Forging', 'Outfitting', 'Engineering',
                   'Alchemy', 'Scholarship', 'Appraisal', 'Tactics', 'Mechanical Lore', 'Performance', 'Empathy',
                   'Enchanting', 'Trading', 'Attunement', 'Arcana', 'Targeted Magic', 'Debilitation', 'Warding',
                   'Augmentation', 'Utility', 'Sorcery', 'Summoning', 'Astrology', 'Theurgy', 'Inner Magic',
                   'Inner Fire', 'Melee Mastery', 'Missile Mastery', 'Parry Ability', 'Small Edged', 'Large Edged',
                   'Twohanded Edged', 'Twohanded Blunt', 'Small Blunt', 'Large Blunt', 'Bow', 'Slings', 'Crossbow',
                   'Polearms', 'Heavy Thrown', 'Offhand Weapon', 'Brawling', 'Light Thrown', 'Staves', 'Expertise',
                   'Defending', 'Shield Usage', 'Light Armor', 'Chain Armor', 'Brigandine', 'Plate Armor', 'Conviction',
                   'Life Magic', 'Holy Magic', 'Lunar Magic', 'Elemental Magic', 'Arcane Magic']
    @neutral_aspects = %w[Everild Kertigen Damaris Tamsine Meraud Truffenyi Glythtide Chadatru Faenella Hodierna Eluned Hav'roth Urrem'tier]
  end
end

DRYamlValidator.new