require "sfn"
require "pathname"

module Sfn
  module Utils

    # Helper methods for path selection
    module PathSelector

      # Humanize the base name of path
      #
      # @param path [String]
      # @return [String]
      def humanize_path_basename(path)
        File.basename(path).sub(
          File.extname(path), ""
        ).split(/[-_]/).map(&:capitalize).join(" ")
      end

      # Prompt user for file selection
      #
      # @param directory [String] path to directory
      # @param opts [Hash] options
      # @option opts [Array<String>] :ignore_directories directory names
      # @option opts [String] :directories_name title for directories
      # @option opts [String] :files_name title for files
      # @option opts [String] :filter_prefix only return results matching filter
      # @return [String] file path
      def prompt_for_file(directory, opts = {})
        file_list = Dir.glob(File.join(directory, "**", "**", "*")).find_all do |file|
          File.file?(file)
        end
        if opts[:filter_prefix]
          file_list = file_list.find_all do |file|
            file.start_with?(options[:filter_prefix])
          end
        end
        directories = file_list.map do |file|
          File.dirname(file)
        end.uniq
        files = file_list.find_all do |path|
          path.sub(directory, "").split("/").size == 2
        end
        if opts[:ignore_directories]
          directories.delete_if do |dir|
            opts[:ignore_directories].include?(File.basename(dir))
          end
        end
        if directories.empty? && files.empty?
          ui.fatal "No formation paths discoverable!"
        else
          output = ["Please select an entry"]
          output << "(or directory to list):" unless directories.empty?
          ui.info output.join(" ")
          output.clear
          idx = 1
          valid = {}
          unless directories.empty?
            output << ui.color("#{opts.fetch(:directories_name, "Directories")}:", :bold)
            directories.each do |dir|
              valid[idx] = {:path => dir, :type => :directory}
              output << [idx, humanize_path_basename(dir)]
              idx += 1
            end
          end
          unless files.empty?
            output << ui.color("#{opts.fetch(:files_name, "Files")}:", :bold)
            files.each do |file|
              valid[idx] = {:path => file, :type => :file}
              output << [idx, humanize_path_basename(file)]
              idx += 1
            end
          end
          max = idx.to_s.length
          output.map! do |o|
            if o.is_a?(Array)
              "  #{o.first}.#{" " * (max - o.first.to_s.length)} #{o.last}"
            else
              o
            end
          end
          ui.info "#{output.join("\n")}\n"
          response = ui.ask_question("Enter selection: ").to_i
          unless valid[response]
            ui.fatal "How about using a real value"
            exit 1
          else
            entry = valid[response.to_i]
            if entry[:type] == :directory
              prompt_for_file(entry[:path], opts)
            elsif Pathname(entry[:path]).absolute?
              entry[:path]
            else
              "/#{entry[:path]}"
            end
          end
        end
      end
    end
  end
end