validate.lic

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]
    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 == settings.spare_gem_pouch_container

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

  def assert_that_weapon_training_are_skills(settings)
    return unless settings.weapon_training

    bad_names = settings.weapon_training.keys
                        .reject { |skill_name| @valid_weapon_skills.include?(skill_name) }
    return if bad_names.empty?

    bad_names.each { |skill_name| error("Invalid weapon_training: skill name '#{skill_name}'") }
    echo("Valid skills are #{@valid_weapon_skills}")
  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

    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_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_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', 'Favor Orb', 'Charged Maneuver', 'Meraud', 'Recall', 'Barb Research Debilitation', 'Barb Research Augmentation', 'Barb Research Warding', 'Collect', 'Analyze', 'PrayerMat'].include?(skill) }
            .each_key { |skill| error("Ability in training_abilities is not valid: #{skill}") }
  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_held_cambrinth_is_deprecated(settings)
    return unless settings.held_cambrinth

    warn('The held_cambrinth setting is deprecated and can be removed from your YAML. We now assume cambrinth is worn (and check your Arcana skill) unless the stored_cambrinth setting is used.')
  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['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_necro_train_first_aid_is_deprecated(settings)
    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

  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_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']

    @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',
                   'Life Magic', 'Holy Magic', 'Lunar Magic', 'Elemental Magic', 'Arcane Magic']
  end
end

DRYamlValidator.new