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

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

    TAG_NONE = ''.freeze
    CENTER_SIZE = 20
    FOREMAN_PREFIX_LENGTH = 18
    FAILOVER_WRAP = 80
    CHAR_FATAL = '⯶'.freeze
    TERMINUS_STRING = '╙─╜'.freeze
    RENDERED_VIEW_DURATION = 100
    TOTAL_RENDERED_VIEW_DURATION = RENDERED_VIEW_DURATION * 5

    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
        ))
      @memory = nil
    end

    def call(log, logger)
      # puts 'ok'
      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)
      return true if log.name == 'ActionView::Base' && log.message&.starts_with?('  Rendering')

      true if log.name == 'Rails' && log.message&.starts_with?('Loaded')
    end

    private

    def tags
      first_tag = log.tags.empty? ? TAG_NONE : log.tags.first
      colorize(centerize(first_tag, 10), BG_GRAY + DARK_TEXT_YELLOW)
    end

    def named_tags
      return if log.named_tags.empty?

      log.named_tags
    end

    def build_regex_redirected
      dev_port = Rails.application.routes.default_url_options[:port]
      dev_hosts = ['127.0.0.1', 'localhost', Rails.application.routes.default_url_options[:host]].uniq.join('|')
      dev_from = "http://(?:#{dev_hosts}):#{dev_port}"
      regex_s = "^(Redirected to )#{dev_from}(.*)"
      Regexp.new(regex_s)
    end

    def ansi_trace(trace, symbol)
      match = trace.match(/(↳ )?(.*:\d+)(:in `)?(.*'?)/) # only m2(=file) and m4(=optional function) are useful
      return trace unless match

      _, m2, _, m4 = match.captures
      "#{symbol} #{m2} #{BOLD}#{m4.chop}#{CLEAR}"
    end

    def two_captures_last_as_bold(message, regex)
      match = message.match(regex)
      return "unmatched: #{message}" unless match

      m1, m2 = match.captures
      "#{m1}#{BOLD}#{m2}#{CLEAR}"
    end

    def alter(log)
      if log.name =~ /^(ActionView|ActiveRecord)::Base/
        log.level = :debug
        log.message.lstrip!
        if log.name == 'ActiveRecord::Base'
          unbold!(log.message)

          if log.message.starts_with?('↳ ')
            log.message = ansi_trace(log.message, '⇄')
          else
            sql_match = log.message.match(/\s+\[\[.*\]\]$/)
            if sql_match
              sql_command = sql_match.pre_match
              sql_type, sql_entry = sql_command.split("\e[0m")
              sql_color_entry = sql_entry.match(ANSI_REGEX).to_s
              sql_args = JSON.parse(sql_match.to_s).map(&:last)
              sql_args.each_with_index do |val, index|
                sql_arg = val.inspect
                sql_arg = "'#{val.gsub("'", "''")}'" if val.is_a?(String)
                sql_entry.gsub!("$#{index + 1}", colorize(sql_arg, BOLD) + sql_color_entry)
              end
              log.message = [sql_type, sql_entry].join(CLEAR)
            end
          end
        elsif log.name == 'ActionView::Base'
          match = log.message.match(/^Rendered( layout| collection of|) (.*?\.erb)(.*)(\(Duration:.*\))/)
          if match
            m1, m2, m3, m4 = match.captures
            duration = m4.match(/Duration: (\d+\.?\d*)ms/).match(1).to_f
            duration = duration < RENDERED_VIEW_DURATION ? '' : m4.to_s
            log.message = "⇤ Rendered#{m1} app/views/#{m2}#{m3}#{duration}"
          end
        end

      end

      log
    end

    def draw_fatal(char = CHAR_FATAL)   = BG_MAGENTA + BOLD + TEXT_WHITE + char + CLEAR
    def origin                          = colorize(centerize(log.name), TEXT_CYAN)
    def build_prefix(char)              = "#{tags} #{origin} ╣#{colorize(char)}╠  "
    def build_terminus                  = "#{tags} #{origin} #{TERMINUS_STRING}  "

    def centerize(text, max_length = CENTER_SIZE) = text.reverse.truncate(max_length).reverse.center(max_length)

    def stackisize(items)
      return '' if items.empty?

      traces = items.map { |item| ansi_trace(item, '➟') }
      "\n#{traces.join("\n")}"
    end

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

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

    def unbold!(text) = text.gsub!(BOLD, '')

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

    def payload
      return unless log.payload

      log.payload.ai(indent: 2, object_id: false)
    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(Rails.backtrace_cleaner.clean(exc.backtrace))

      "#{clazz}#{message}#{backtrace}"
    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|
        Semantic::AnsiWrapper.wrap(item, length, prefix, continuation)
      end

      if log.dimensions&.terminus
        terminus = Semantic::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
end