# frozen_string_literal: true

require './lib/api_error/base_error'

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)
      raise APIError::BaseError, "Cannot use 'id' and 'iid' in the same query." if args[:id] && args[:iid]

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

    def combine_ids_with_iids!(args)
      args[:ids] = [*args[:ids], *args.delete(:iids)] if args[:iids]
    end

    def combine_plurals!(args)
      plurals.each do |singular, plural|
        next unless args[plural]

        singular_arg = args[singular]
        args[singular] = [*args.delete(plural)]
        args[singular].unshift(singular_arg) if singular_arg
      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)
      combine_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