# frozen_string_literal: true

module Resolvers
  class BaseResolver < GraphQL::Schema::Resolver
    def self.argument_with_plural(field, type, **args)
      plural_sym = field.to_s.pluralize.to_sym
      plurals[field] = plural_sym

      argument(field, type, args)
      argument(plural_sym, [type], args.dup.tap { |a| a[:required] = false })
    end

    def self.plurals
      @plurals ||= {}
    end

    def plurals
      self.class.plurals
    end

    def clobber_id_with_iid!(args)
      args[:id] = args.delete(:iid) if args[:iid]
    end

    def clobber_ids_with_iids!(args)
      args[:ids] = args.delete(:iids) if args[:iids]
    end

    def combine_plurals!(args)
      plurals.each do |singular, plural|
        args[singular] = [args[singular], *args.delete(plural)] if args[plural]
      end
    end

    def decode_id(args)
      if (id = args[:id])
        _, iid = GraphQL::Schema::UniqueWithinType.decode(id)
        args[:id] = iid
      end
    end

    def decode_ids(args)
      if (ids = args[:ids])
        ids.map! { |i| GraphQL::Schema::UniqueWithinType.decode(i).last }
        args[:ids] = ids
      end
    end

    def prepare_args!(args)
      decode_id(args)
      decode_ids(args)
      clobber_id_with_iid!(args)
      clobber_ids_with_iids!(args)
      combine_plurals!(args)
    end

    def self.single
      @single ||= Class.new(self) do
        def resolve(**args)
          super.first
        end
      end
    end
  end
end