class HighLine::Menu

def add_item(item)
  @items << item
  @help.merge!(item.item_help)
  update_responses
end

def all_items
  @items + @hidden_items
end

def build_item(*args)
  Menu::Item.new(*args)
end

def choice(name, help = nil, text = nil, &action)
  item = Menu::Item.new(name, text: text, help: help, action: action)
  @items << item
  @help.merge!(item.item_help)
  update_responses # rebuild responses based on our settings
end

def choices(*names, &action)
  names.each { |n| choice(n, &action) }
end

def decorate_index(index)
  if index_color
    HighLine.color(index, index_color)
  else
    index
  end
end

def decorate_item(text, ix)
  decorated, non_decorated = mark_for_decoration(text, ix)
  decorate_index(decorated) + non_decorated
end

def find_item_from_selection(items, selection)
  if selection =~ /^\d+$/ # is a number?
    get_item_by_number(items, selection)
  else
    get_item_by_letter(items, selection)
  end
end

def gather_selected(highline_context, selections, details = nil)
  @highline = highline_context
  # add in any hidden menu commands
  items = all_items
  if selections.is_a?(Array)
    value_for_array_selections(items, selections, details)
  elsif selections.is_a?(Hash)
    value_for_hash_selections(items, selections, details)
  else
    raise ArgumentError, "selections must be either Array or Hash"
  end
end

def get_item_by_letter(items, selection)
  item = items.find { |i| i.name == selection }
  return item if item
  # 97 is the "a" letter at ascii table
  # Ex: For "a" it will return 0, and for "c" it will return 2
  index = selection.downcase.ord - 97
  items[index]
end

def get_item_by_number(items, selection)
  items[selection.to_i - 1]
end

def help(topic, help)
  @help[topic] = help
end

def hidden(name, help = nil, &action)
  item = Menu::Item.new(name, text: name, help: help, action: action)
  @hidden_items << item
  @help.merge!(item.item_help)
end

def index=(style)
  @index = style
  return unless @index == :none || @index.is_a?(::String)
  # Default settings.
  @index_suffix = " "
  @select_by    = :name
end

def init_help
  return if @items.include?(:help)
  topics    = @help.keys.sort
  help_help =
    if @help.include?("help")
      @help["help"]
    else
      "This command will display helpful messages about " \
        "functionality, like this one.  To see the help for " \
        "a specific topic enter:\n\thelp [TOPIC]\nTry asking " \
        "for help on any of the following:\n\n" \
        "<%= list(#{topics.inspect}, :columns_across) %>"
    end
  choice(:help, help_help) do |_command, topic|
    topic.strip!
    topic.downcase!
    if topic.empty?
      @highline.say(@help["help"])
    else
      @highline.say("= #{topic}\n\n#{@help[topic]}")
    end
  end
end

def initialize
  #
  # Initialize Question objects with ignored values, we'll
  # adjust ours as needed.
  #
  super("Ignored", [], &nil) # avoiding passing the block along
  @items           = []
  @hidden_items    = []
  @help            = Hash.new("There's no help for that topic.")
  @index           = :number
  @index_suffix    = ". "
  @select_by       = :index_or_name
  @flow            = :rows
  @list_option     = nil
  @header          = nil
  @prompt          = "?  "
  @layout          = :list
  @shell           = false
  @nil_on_handled  = false
  # Used for coloring Menu indices.
  # Set it to default. But you may override it.
  @index_color     = self.class.index_color
  # Override Questions responses, we'll set our own.
  @responses       = {}
  # Context for action code.
  @highline        = nil
  yield self if block_given?
  init_help if @shell && !@help.empty?
end

def layout=(new_layout)
  @layout = new_layout
  # Default settings.
  case @layout
  when :one_line, :menu_only
    self.index = :none
    @flow = :inline
  end
end

def map_items_by_index
  size = all_items.size
  case @index
  when :letter
    ("a".."z").first(size)
  when :capital_letter
    ("A".."Z").first(size)
  else
    (1..size).map(&:to_s)
  end
end

def map_items_by_name
  all_items.map(&:name)
end

def mark_for_decoration(text, ix)
  case @index
  when :number
    ["#{ix + 1}#{@index_suffix}", text]
  when :letter, :capital_letter
    first_letter = (@index == :capital_letter ? 'A' : 'a')
    ["#{(first_letter.ord + ix).chr}#{@index_suffix}", text]
  when :none
    [text, ""]
  else
    ["#{index}#{@index_suffix}", text]
  end
end

def options
  case @select_by
  when :index
    map_items_by_index
  when :name
    map_items_by_name
  else
    map_items_by_index + map_items_by_name
  end
end

def parse_list
  "<%= list( menu, #{@flow.inspect},
       #{@list_option.inspect} ) %>"
end

def select(highline_context, selection, details = nil)
  # add in any hidden menu commands
  items = all_items
  # Find the selected action.
  selected_item = find_item_from_selection(items, selection)
  # Run or return it.
  @highline = highline_context
  value_for_selected_item(selected_item, details)
end

def show_default_if_any
  default.to_s.empty? ? "" : "(#{default}) "
end

def to_ary
  @items.map.with_index { |item, ix| decorate_item(item.text.to_s, ix) }
end

def to_s
  case @layout
  when :list
    %(<%= header ? "#{header}:\n" : '' %>) +
      parse_list +
      show_default_if_any +
      "<%= prompt %>"
  when :one_line
    %(<%= header ? "#{header}:  " : '' %>) +
      "<%= prompt %>" \
      "(" + parse_list + ")" +
      show_default_if_any +
      "<%= prompt[/\s*$/] %>"
  when :menu_only
    parse_list +
      show_default_if_any +
      "<%= prompt %>"
  else
    @layout
  end
end

def update_responses
  build_responses(options)
end

def value_for_array_selections(items, selections, details)
  # Find the selected items and return values
  selected_items = selections.map do |selection|
    find_item_from_selection(items, selection)
  end
  index = 0
  selected_items.map do |selected_item|
    value = value_for_selected_item(selected_item, self.shell ? details[index] : nil)
    index += 1
    value
  end
end

def value_for_hash_selections(items, selections, details)
  # Find the selected items and return in hash form
  index = 0
  selections.each_with_object({}) do |(key, selection), memo|
    selected_item = find_item_from_selection(items, selection)
    value = value_for_selected_item(selected_item, self.shell ? details[index] : nil)
    index += 1
    memo[key] = value
  end
end

def value_for_selected_item(item, details)
  if item.action
    result = if @shell
               item.action.call(item.name, details)
             else
               item.action.call(item.name)
             end
    @nil_on_handled ? nil : result
  else
    item.name
  end
end