require 'tins/terminal'
require 'term/ansicolor'

begin
  require 'rspec/core'
  require 'rspec/core/formatters'
rescue LoadError => e
  $DEBUG and warn "Caught #{e.class}: #{e}"
else
  module Utils
    class LineFormatter
        ::RSpec::Core::Formatters.register self, :start, :close,
          :example_passed, :example_pending, :example_failed, :dump_summary

        def initialize(output)
          @output = output
          @output.sync = true
          filename = 'errors.lst'
          @errors_lst = File.new(filename, 'w')
          @errors_lst.sync = true
        end

        attr_reader :output

        def start(_ignore)
          output.puts "Storing error list in #{@errors_lst.path.inspect}: "
          output.puts ?- * Tins::Terminal.columns
        end

        def close(_ignore)
          @errors_lst.close
        end

        def dump_summary(summary)
          line = summary_line(summary)
          @errors_lst.puts ?= * 80, line
          output.puts ?= * Tins::Terminal.columns, line
        end

        def example_passed(example)
          output.puts format_line(example)
        end

        def example_pending(example)
          output.puts format_line(example)
        end

        def example_failed(example)
          dump_failure_to_error_file(example)
          output.puts format_line(example)
          dump_failure(example)
        end

        private

        def summary_line(summary)
          failure_percentage = 100 * summary.failure_count.to_f / summary.example_count
          failure_percentage.nan? and failure_percentage = 0.0
          pending_percentage = 100 * summary.pending_count.to_f / summary.example_count
          pending_percentage.nan? and pending_percentage = 0.0
          "%u of %u (%.2f %%) failed, %u pending (%.2f %%) in %.3f seconds" % [
            summary.failure_count,
            summary.example_count,
            failure_percentage,
            summary.pending_count,
            pending_percentage,
            summary.duration,
          ]
        end

        def dump_failure(example)
          output.puts(
            description(example, full: true),
            dump_failure_for_example(example)
          )
        end

        def read_failed_line(example)
          ''.strip
        end

        def dump_failure_for_example(example)
          result = ''
          exception = execution_result(example).exception
          exception_class_name = exception.class.name
          result << "Failure/Error: #{read_failed_line(example)}\n"
          result << "#{exception_class_name}:\n" unless exception_class_name =~ /RSpec/
          if m = exception.message
            m.to_s.split("\n").each { |line| result << "  #{line}\n" }
          end
          result
        end

        def format_backtrace(example, folding: false, limit: nil)
          backtrace = execution_result(example).exception.backtrace
          backtrace.nil? and return ''
          if limit
            backtrace = backtrace[0, limit]
          end
          result = []
          folding and result << '{{{'
          for line in backtrace
            result << RSpec::Core::Metadata::relative_path(line)
          end
          folding and result << '}}}'
          result * ?\n
        end

        def dump_failure_to_error_file(example)
          @errors_lst.flock File::LOCK_EX
          @errors_lst.puts "%s\n%3.3fs %s\n%s\n%s" % [
            location(example), run_time(example), description(example, full: true),
            dump_failure_for_example(example), format_backtrace(example, folding: true)
          ]
        ensure
          @errors_lst.flock File::LOCK_UN
        end

        def execution_result(example)
          example.example.metadata[:execution_result]
        end

        def description(example, full: ENV['VERBOSE'].to_i == 1)
          if full
            example.example.full_description
          else
            example.example.description
          end
        end

        def run_time(example)
          execution_result(example).run_time
        end

        def format_line(example)
          args = [ location(example), run_time(example), description(example) ]
          uncolored = "%s # S %3.3fs %s" % args
          uncolored = uncolored[0, Tins::Terminal.columns]
          case execution_result(example).status
          when :passed
            success_color(uncolored)
          when :failed
            failure_color(uncolored)
          when :pending
            pending_color(uncolored)
          else
            uncolored % args
          end
        end

        def success_color(text)
          Term::ANSIColor.green(text)
        end

        def failure_color(text)
          Term::ANSIColor.red(text)
        end

        def pending_color(text)
          Term::ANSIColor.yellow(text)
        end

        def location(example)
          location = example.example.metadata[:location]
          unless location.include?(?/)
            location = example.example.metadata[:example_group][:location]
          end
          RSpec::Core::Metadata::relative_path(location)
        end
    end
  end
end