# frozen_string_literal: true

module GraphQL
  module Tracing
    module PlatformTrace
      def initialize(trace_scalars: false, **_options)
        @trace_scalars = trace_scalars
        @platform_field_key_cache = Hash.new { |h, k| h[k] = platform_field_key(k) }
        @platform_authorized_key_cache = Hash.new { |h, k| h[k] = platform_authorized_key(k) }
        @platform_resolve_type_key_cache = Hash.new { |h, k| h[k] = platform_resolve_type_key(k) }
        super
      end

      def platform_execute_field_lazy(*args, &block)
        platform_execute_field(*args, &block)
      end

      def platform_authorized_lazy(key, &block)
        platform_authorized(key, &block)
      end

      def platform_resolve_type_lazy(key, &block)
        platform_resolve_type(key, &block)
      end

      def self.included(child_class)
        # Don't gather this unless necessary
        pass_data_to_execute_field = child_class.method_defined?(:platform_execute_field) &&
          child_class.instance_method(:platform_execute_field).arity != 1

        [:execute_field, :execute_field_lazy].each do |field_trace_method|
          if !child_class.method_defined?(field_trace_method)
            child_class.module_eval <<-RUBY, __FILE__, __LINE__
              def #{field_trace_method}(query:, field:, ast_node:, arguments:, object:)
                return_type = field.type.unwrap
                trace_field = if return_type.kind.scalar? || return_type.kind.enum?
                  (field.trace.nil? && @trace_scalars) || field.trace
                else
                  true
                end
                platform_key = if trace_field
                  @platform_field_key_cache[field]
                else
                  nil
                end
                if platform_key && trace_field
                  platform_#{field_trace_method}(platform_key#{pass_data_to_execute_field ? ", { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }" : ""}) do
                    super
                  end
                else
                  super
                end
              end
            RUBY
          end
        end


        [:authorized, :authorized_lazy].each do |auth_trace_method|
          if !child_class.method_defined?(auth_trace_method)
            child_class.module_eval <<-RUBY, __FILE__, __LINE__
              def #{auth_trace_method}(type:, query:, object:)
                platform_key = @platform_authorized_key_cache[type]
                platform_#{auth_trace_method}(platform_key) do
                  super
                end
              end
            RUBY
          end
        end

        [:resolve_type, :resolve_type_lazy].each do |rt_trace_method|
          if !child_class.method_defined?(rt_trace_method)
            child_class.module_eval <<-RUBY, __FILE__, __LINE__
              def #{rt_trace_method}(query:, type:, object:)
                platform_key = @platform_resolve_type_key_cache[type]
                platform_#{rt_trace_method}(platform_key) do
                  super
                end
              end
            RUBY
          end
        end
      end



      private

      # Get the transaction name based on the operation type and name if possible, or fall back to a user provided
      # one. Useful for anonymous queries.
      def transaction_name(query)
        selected_op = query.selected_operation
        txn_name = if selected_op
          op_type = selected_op.operation_type
          op_name = selected_op.name || fallback_transaction_name(query.context) || "anonymous"
          "#{op_type}.#{op_name}"
        else
          "query.anonymous"
        end
        "GraphQL/#{txn_name}"
      end

      def fallback_transaction_name(context)
        context[:tracing_fallback_transaction_name]
      end
    end
  end
end