module Dry
  # rubocop:disable Style/AsciiIdentifiers
  # rubocop:disable Style/MultilineBlockChain
  # rubocop:disable Style/EmptyCaseCondition
  # rubocop:disable Metrics/PerceivedComplexity
  # rubocop:disable Metrics/CyclomaticComplexity
  # rubocop:disable Metrics/AbcSize
  module BlackTie
    class << self
      def protocols
        @protocols ||= Hash.new { |h, k| h[k] = h.dup.clear }
      end

      def implementations
        @implementations ||= Hash.new { |h, k| h[k] = h.dup.clear }
      end
    end

    def defprotocol
      raise if BlackTie.protocols.key?(self) # DUPLICATE DEF
      raise unless block_given?

      ims = instance_methods(false)
      class_eval(&Proc.new)
      (instance_methods(false) - ims).each { |m| class_eval { module_function m } }

      singleton_class.send :define_method, :method_missing do |method, *args|
        raise Dry::Protocol::NotImplemented.new(:method, self.inspect, method)
      end

      BlackTie.protocols[self].each do |method, *_| # FIXME: CHECK PARAMS CORRESPONDENCE HERE
        singleton_class.send :define_method, method do |receiver = nil, *args|
          impl = receiver.class.ancestors.lazy.map do |c|
            BlackTie.implementations[self].fetch(c, nil)
          end.reject(&:nil?).first

          raise Dry::Protocol::NotImplemented.new(:protocol, self.inspect, receiver.class) unless impl
          impl[method].(*args.unshift(receiver))
        end
      end
    end

    def defmethod(name, *params)
      BlackTie.protocols[self][name] = params
    end

    DELEGATE_METHOD = lambda do |klazz, (source, target)|
      klazz.class_eval do
        define_method source do |this, *args, **params, &λ|
          case
          when !args.empty? && !params.empty? then this.send(target, *args, **params, &λ)
          when !args.empty? then this.send(target, *args, &λ)
          when !params.empty? then this.send(target, **params, &λ)
          else this.send(target, &λ)
          end
        end
      end
    end

    def defimpl(protocol = nil, target: nil, delegate: [], map: {})
      raise if target.nil? || !block_given? && delegate.empty? && map.empty?

      mds = normalize_map_delegates(delegate, map)
      Module.new do
        mds.each(&DELEGATE_METHOD.curry[singleton_class])
        singleton_class.class_eval(&Proc.new) if block_given? # block takes precedence
      end.tap do |mod|
        mod.methods(false).tap do |meths|
          (BlackTie.protocols[protocol || self].keys - meths).each_with_object(meths) do |m, acc|
            safe_logger.warn("Implicit delegate #{(protocol || self).inspect}##{m} to #{target}")
            DELEGATE_METHOD.(mod.singleton_class, [m] * 2)
            acc << m
          end
        end.each do |m|
          [*target].each do |tgt|
            BlackTie.implementations[protocol || self][tgt][m] = mod.method(m).to_proc
          end
        end
      end
    end
    module_function :defimpl

    private

    def safe_logger
      if Kernel.const_defined?('::Rails')
        Rails.logger
      else
        require 'logger'
        Logger.new($stdout)
      end
    end

    def normalize_map_delegates(delegate, map)
      [*delegate, *map].map do |e|
        case e
        when Symbol, String then [e.to_sym] * 2
        when Array then e.map(&:to_sym) if e.size == 2
        end
      end.compact
    end
    module_function :normalize_map_delegates
  end
  # rubocop:enable Metrics/AbcSize
  # rubocop:enable Metrics/CyclomaticComplexity
  # rubocop:enable Metrics/PerceivedComplexity
  # rubocop:enable Style/EmptyCaseCondition
  # rubocop:enable Style/MultilineBlockChain
  # rubocop:enable Style/AsciiIdentifiers
end