# frozen_string_literal: true

require 'datasync/dsl/mapping_dsl'
require 'datasync/dsl/handler_dsl'

module Datasync
  module DSL
    # Implements the top-level DSL for configuring a mapper
    class MapperDSL
      def initialize(mapper)
        @mapper = mapper
      end

      def title(text)
        @mapper.title = text
      end

      def source(key, &block)
        raise ArgumentError, 'No block was specified for source' unless block_given?

        @mapper.source_key = key
        @mapper.source_proc = block
      end

      def target(key, &block)
        raise ArgumentError, 'No block was specified for target' unless block_given?

        @mapper.target_key = key
        @mapper.target_proc = block
      end

      def target_key_from(where)
        raise ArgumentError, 'Invalid target key strategy' unless %i[database object].include? where

        @mapper.target_key_from_db = (where == :database)
      end

      def match_using(*fields)
        @mapper.match_fields = fields
      end

      def match_when(*situations)
        @mapper.match_situations = situations
      end

      def parser(field, &block)
        raise ArgumentError, 'No block was specified for parse' unless block_given?

        @mapper.parser(field, block)
      end

      def formatter(field, &block)
        raise ArgumentError, 'No block was specified for format' unless block_given?

        @mapper.formatter(field, block)
      end

      def mapping(&block)
        @mapper.mapping_proc = proc do |source, old_target = nil|
          new_target = {}
          MappingDSL.new(source, old_target, new_target).instance_eval(&block)
          new_target
        end
      end

      def option(block_name = nil, **options, &block)
        if block_name
          raise ArgumentError, 'No options allowed when setting a block' unless options.empty?
          raise ArgumentError, 'No block was supplied for a block option' unless block_given?

          @mapper.option(block_name, block)
        else
          raise ArgumentError, 'No block is permitted when setting other options' if block_given?

          options.each do |name, value|
            @mapper.option(name, value)
          end
        end
      end

      def on(situation, &block)
        handler = proc do |*args|
          HandlerDSL.new(*args).instance_eval(&block)
        end
        @mapper.handler(situation, handler)
      end

      def limit(**limits)
        limits.each do |type, max|
          @mapper.limit(type, max)
        end
      end
    end
  end
end