#!/usr/bin/env ruby

require 'bundler/setup'
require 'term/ansicolor'
require 'pain'

include Pain

class String
  include Term::ANSIColor
end

def get_color(value)
  offset = case value
           when :trivial
             40
           when :minor
             69
           when :standard
             184
           when :major
             202
           when :critical
             9
           else
             252
     end
  Term::ANSIColor::Attribute[offset]
end

def case_danger(danger)
  if danger < 0.21
    :trivial
  elsif danger < 0.41
    :minor
  elsif danger < 0.65
    :standard
  elsif danger < 0.81
    :major
  else
    :critical
  end
end

def total_danger(danger)
  if danger < 21
    :trivial
  elsif danger < 31
    :minor
  elsif danger < 51
    :standard
  elsif danger < 75
    :major
  else
    :critical
  end
end

def color_output(msg, danger = :normal)
  level = if danger == :normal
            :default
    elsif danger.is_a? Symbol
      danger
    else
            case_danger(danger)
    end
  puts msg.color(get_color(level))
end

def display_options_for(input)
  ceiling = Pain::OPTIONS[input].count
  Pain::OPTIONS[input].each do |v, msg|
    color_output("#{v}: #{msg}", (v/ceiling.to_f))
  end
  puts
end

def ask_question_for(input)
  color_output Pain::INPUT_MESSAGE[input]
end

def print_report_for(o)
  pain = Pain.user_pain(o[:bug_type], o[:likelihood], o[:impact])

  levels = o.reduce({}) do |hash, (input, level)|
    hash[input] = case_danger(level.to_f /  Pain::MAX[input])
    hash
  end

  color_output  "Type:       #{o[:bug_type]} - #{Pain::OPTIONS[:bug_type][o[:bug_type]]}", levels[:bug_type]
  color_output  "Likelihood: #{o[:likelihood]} - #{Pain::OPTIONS[:likelihood][o[:likelihood]]}", levels[:likelihood]
  color_output  "Impact:     #{o[:impact]} - #{Pain::OPTIONS[:impact][o[:impact]]}", levels[:impact]
  puts
  color_output "User Pain: #{pain}", total_danger(pain)
end


options = {}

OptionParser.new do |opts|
  opts.on('-l', '--likelihood [LIKELIHOOD]', OptionParser::DecimalInteger,
    'How likely is this bug to occur?') do |like|
    options[:likelihood] = Pain::normalize(like, :likelihood)
  end

  opts.on('-i', '--impact [IMPACT]', OptionParser::DecimalInteger,
    'How much impact will this bug have?') do |impact|
    options[:impact] = Pain.normalize(impact, :impact)
  end

  opts.on('-t', '--type [TYPE]', OptionParser::DecimalInteger,
    'What kind of bug is this?') do |bug_type|
    options[:bug_type] = Pain.normalize(bug_type, :bug_type)
  end
end.parse!

[:bug_type, :likelihood, :impact].each do |input|
  first = true
  until options[input]
    ask_question_for input
    display_options_for(input) if first

    response       = gets.chomp
    options[input] = Pain::normalize(response, input)
    first          = false
  end
end

print_report_for options