# encoding: utf-8
# frozen_string_literal: true

require "forwardable"

module Carbon
  module Concrete
    # A "request."  This is used to note the generics that a given module
    # should be compiled with.  This is used for items to note the dependencies
    # that an item has; otherwise, it is used in the index for build
    # information.
    #
    # @note
    #   **This class is frozen upon initialization.**  This means that any
    #   attempt to modify it will result in an error.  In most cases, the
    #   attributes on this class will also be frozen, as well.
    class Request
      extend Forwardable

      # The interned name of a module.  This is used for module lookup.  This
      # contains no generic information.  For generic functions, all generics
      # are pushed onto the defining module.
      #
      # @api public
      # @example
      #   request.intern # => "Carbon::Pointer"
      # @note See {Item::Base#intern} For more information about interned
      #   names.
      # @return [::String]
      attr_reader :intern

      # The generics of the request.  Even if the request has no definable
      # generics, these are still kept in place for both name information and
      # for placement information (e.g. identity and size).
      #
      # @api public
      # @example
      #   request.generics # => [#<Carbon::Concrete::Type::Generic T>]
      # @return [<Type::Generic>]
      attr_reader :generics

      # Initialize the request with the given interned name and generics,
      # and then freezes the request.
      #
      # @api public
      # @see #intern
      # @see #generics
      # @param intern [::String] The interned name.
      # @param generics [<Type::Generic>] The generics.
      def initialize(intern, generics)
        @intern = intern
        @generics = generics
        deep_freeze!
      end

      # Replaces this request or this request's generics with the corresponding
      # correct module.  This is designed to resolve generic names; for
      # example, it resolves `Carbon::Pointer<T>` to
      # `Carbon::Pointer<Carbon::String>` with the right argument.  It checks
      # for three seperate cases.
      #
      # 1. The request has no generics, and the request's {#intern} has a
      #   mapping in the argument.  In this case, it creates a new request
      #   object with the new module's name and no generics (because the
      #   mapping could not have added any worthwhile generics).
      # 2. The request has no generics, and the request's {#intern} has no
      #   mapping in the argument.  In this case, it returns itself.
      # 3. The request has generics.  In this case, the generics are mapped
      #   using {Type::Generic#sub}, and a new request is created with the
      #   mapped generics.
      #
      # @api public
      # @example
      #   string # => #<Carbon::Concrete::Type::Generic Carbon::String>
      #   request.intern # => "Carbon::Pointer"
      #   request.generics # => [#<Carbon::Concrete::Type::Generic T>]
      #   mapped = request.sub("T" => string)
      #   mapped.intern # => "Carbon::Pointer"
      #   request.generics.first.equal?(string) # => true
      # @param mapping [{::String => Type::Generic}] The mapping.
      # @return [Request] The new request, if the request has no generics,
      #   and the request's {#intern} is not a key in the mapping, or if
      #   the request has generics.
      # @return [self] If the request has no generics and it is not a key
      #   in the mapping.
      def sub(mapping)
        case [@generics.none?, mapping.key?(@intern)]
        when [true, true]
          Request.new(mapping[@intern].name.intern, [])
        when [true, false]
          self
        else
          generics = @generics.map { |generic| generic.sub(mapping) }
          Request.new(intern, generics)
        end
      end

      # Compares this request to another.  If this request _is_ the other
      # request, it returns true; otherwise, if the other is a request, and
      # the other request's {#intern} is equal to this request's, it
      # returns true; otherwise, it returns false.
      #
      # @api public
      # @param other [Request, ::String, ::Object] The object to compare.
      # @return [::Boolean]
      def ==(other)
        equal?(other) ||
          (other.is_a?(Request) && other.intern == intern &&
            other.generics == generics)
      end

      alias_method :eql?, :==

      # Creates a hash of the request.  This is used mostly in the Hash
      # class.
      #
      # @api private
      # @return [Numeric]
      def hash
        @intern.hash
      end

      # Returns a string representation of this request.  This includes all
      # generics that are associated with the request, if applicable.
      #
      # @api public
      # @return [::String]
      def to_s
        if @generics.any?
          "#{@intern}<#{@generics.map(&:to_s).join(', ')}>".freeze
        else
          @intern
        end
      end
    end
  end
end