require_relative 'ansi_wrapper'
require_relative 'ansi_colors'
require_relative 'ansi_dimensions'

require 'io/console'
require 'amazing_print'
require 'json'

# wraps meanwhile takes care of ansi colors
class AnsiFormatter < SemanticLogger::Formatters::Color
  include AnsiColors

  $memory = nil

  CENTER_SIZE = 20
  FOREMAN_PREFIX_LENGTH = 18
  FAILOVER_WRAP = 80
  CHAR_FATAL = '⯶'.freeze
  TERMINUS_STRING = '╙─╜'.freeze

  def initialize
    super(color_map:
      ColorMap.new(
        debug: CLEAR + TEXT_GRAY_400,
        info: CLEAR + TEXT_GRAY_100,
        warn: CLEAR + BG_YELLOW + TEXT_BLACK,
        error: CLEAR + BG_RED + TEXT_WHITE,
        fatal: CLEAR + BG_MAGENTA + BOLD + TEXT_WHITE
      ))
  end

  def call(log, logger)
    log = alter(log)

    self.log = log
    self.logger = logger
    self.color = color_map[log.level]

    wrap_level(compute_useful_length, message, payload, exception)
  end

  def reject(log)
    log.name == 'ScoresController' || false
    false
  end

  private

  def alter(log)
    if log.name == 'Rails'
      if log.message
        log.message.chomp!('')
        if log.message.starts_with?('Started')
          rails = '╓─╖'
          before = 1
          if $memory
            rails = "╓#{$memory}╖"
            before = 0
          end
          log.dimensions = AnsiDimensions.new(rails:, before:)
          $memory = nil
        elsif log.message.starts_with?('Completed 2')
          log.dimensions = AnsiDimensions.new(rails: TERMINUS_STRING, after: 1)
        elsif log.message.starts_with?('Completed 3')
          $memory = '║'
          log.dimensions = AnsiDimensions.new(rails: "╙#{$memory}╜")
        elsif log.message.starts_with?('Completed 4')
          log.dimensions = AnsiDimensions.new(rails: '╙╨╜')
        elsif log.message.starts_with?('Completed 5')
          log.dimensions = AnsiDimensions.new(rails: "╙#{draw_fatal}╜")
        end
      elsif log.exception
        log.dimensions = AnsiDimensions.new(
          rails: "╓#{draw_fatal(log.level.to_s.chr.upcase)}╖",
          after: 1,
          terminus: true
        )
      end
    end
    log
  end

  def draw_fatal(char = CHAR_FATAL)
    AnsiColors::BG_MAGENTA + AnsiColors::BOLD + AnsiColors::TEXT_WHITE + char + AnsiColors::CLEAR
  end

  def origin                          = colorize(centerize(log.name), TEXT_CYAN)
  def build_prefix(char)              = "#{origin} ╣#{colorize(char)}╠  "
  def build_terminus                  = "#{origin} #{TERMINUS_STRING}  "
  def centerize(text)                 = text.truncate(CENTER_SIZE).center(CENTER_SIZE)
  def colorize(text, tint = color)    = "#{tint}#{text}#{CLEAR}"
  def stackisize(items)               = items.length.positive? ? "\n#{items.join("\n")}" : ''

  def build_dimensions(dimensions)
    "#{origin} #{dimensions.rails}  "
  end

  def compute_useful_length
    IO.console.winsize[1] - FOREMAN_PREFIX_LENGTH
  rescue StandardError
    FAILOVER_WRAP
  end

  def message
    colorize(log.message) if log.message
  end

  def exception
    return unless log.exception

    exc = log.exception
    clazz = colorize("#{exc.class}\n", color_map[:fatal])
    message = colorize(exc.message.chomp(''), color_map[:error])
    backtrace = stackisize(clean_backtrace(exc.backtrace))

    "#{clazz}#{message}#{backtrace}"
  end

  def clean_backtrace(backtrace)
    root_path = Rails.root.to_s
    backtrace = backtrace.select { |line| line.starts_with?(root_path) }
    backtrace.map { |line| line.delete_prefix("#{root_path}/") }
  end

  def level_char
    case log.level
    when :info, :debug then ' '
    else log.level.to_s.chr.upcase
    end
  end

  def wrap_level(length, *items)
    prefix = log.dimensions ? build_dimensions(log.dimensions) : build_prefix(level_char)
    continuation = build_prefix('┆')

    result = items.map do |item|
      AnsiWrapper.wrap(item, length, prefix, continuation)
    end

    if log.dimensions&.terminus
      terminus = AnsiWrapper.wrap(' ', length, build_terminus)
      result << terminus
    end

    log.dimensions&.before&.times { result.unshift('') }
    log.dimensions&.after&.times { result << '' }
    result.compact.join("\n")
  end
end