module Eco
  class CLI
    class Scripting
      module ArgsHelpers
        class UnknownArgument < ArgumentError; end

        # @return [Array<String] the command line arguments.
        def argv
          @argv || ARGV
        end

        def is_modifier?(value) # rubocop:disable Naming/PredicateName
          Argument.is_modifier?(value)
        end

        # @return [Arguments] supported known arguments.
        def arguments
          @arguments ||= Arguments.new(argv)
        end

        # Registers an argument as a known one.
        def known_argument(key, with_param: false)
          arguments.add(key, with_param: with_param)
        end

        # Validation to stop the `script` if among `argv` there's any **unknown** argument.
        def stop_on_unknown!(exclude: [], only_options: false, all_available: nil)
          # validate only those that are options
          suggestions = {}
          args        = {
            exclude:       exclude,
            all_available: all_available
          }
          unknown = arguments.unknown(**args) do |key, correct|
            next suggestions[key] = correct unless correct.empty?

            suggestions[key] = ['-- not known similar options! --']
          end
          unknown = unknown.select {|arg| is_modifier?(arg)} if only_options

          return if unknown.empty?

          suggestions_str = suggestions.slice(*unknown).map do |key, correct|
            str      = "Unknown option '#{key}'."
            str_corr = correct.map {|ky| "'#{ky}'"}
            str     << " Did you mean: #{str_corr.join(', ')}" unless correct.empty?
            str
          end.join("\n  * ")

          msg  = "\nThere are UNKNOWN OPTIONS in your command line arguments !!"
          msg << "\n  * #{suggestions_str}\n"
          msg << "\nUse 'ruby main.rb -org [-usecase] --help -options' for more information"
          msg << "\n  - Please, remember that use case specific options "
          msg << "should come after the use case in the command line.\n"
          raise UnknownArgument, msg
        end

        # @return [Boolean] if `key` is in the command line.
        def arg?(key)
          argv.include?(key)
        end

        # @return [Integer, nil] the position of `key` in the command line.
        def get_arg_index(key)
          return unless arg?(key)

          argv.index(key)
        end

        # @return [Boolean] if `key1` precedes `key2` in the command line.
        def arg_order?(key_1, key_2)
          k_1 = get_arg_index(key_1)
          k_2 = get_arg_index(key_2)
          return false unless k_1 && k_2

          k_1 < k_2
        end

        # @return [String, Boolean] the argument value if `with_param` or a `Boolean` if not.
        def get_arg(key, with_param: false, valid: true)
          # track what a known option looks like
          known_argument(key, with_param: with_param)
          return nil  unless (index = get_arg_index(key))
          return true unless with_param

          value  = argv[index + 1]
          #puts "modifier argument: #{value}"
          value  = nil if valid && is_modifier?(value)
          value
        end

        # @return [String] the filename.
        def get_file(key, required: false, should_exist: true)
          filename = get_arg(key, with_param: true)
          if !filename && required
            puts "You need to specify a file or folder '#{key} file_or_folder'"
            exit(1)
          elsif !file_exists?(filename) && should_exist && required
            puts "This file/folder doesn't exist '#{filename}'"
            exit(1)
          end

          filename = File.expand_path(filename) if filename && should_exist
          filename
        end

        private

        def file_exists?(filename)
          return false if filename.nil?

          File.exist?(filename) || File.exist?(File.expand_path(filename))
        end
      end
    end
  end
end