require "mountapi/response"
require "mountapi/route/parameters"
require "mountapi/route/path"
require "mountapi/route/method"
require "mountapi/route/handler"
require "mountapi/route/responses"

module Mountapi
  module Route
    # Factory method
    def self.build(options)
      Route.new(
        Path.new(options.fetch(:path)),
        Method.new(options.fetch(:method)),
        Handler.new(options.fetch(:handler)),
        Parameters.build(options.fetch(:parameters, [])),
        Responses.build(options.fetch(:responses, [])),
        options.fetch(:version, '0.0.0'),
        options.fetch(:operation_id)
      )
    end

    # an http route associated to a handler
    class Route
      include Comparable
      attr_reader :path, :method, :handler, :parameters, :responses, :version,
                  :operation_id

      # @param [Mountapi::Route::Path] path
      # @param [Mountapi::Route::Method] method
      # @param [Mountapi::Route::Handler] handler
      # @param [Mountapi::Route::Parameters] params
      # @param [Mountapi::Route::Responses] resps
      # @param [String] ver
      def initialize(path, method, handler, params, resps, ver, op_id)
        @path = path
        @method = method
        @handler = handler
        @parameters = params
        @responses = resps
        @version = ver
        @operation_id = op_id
      end

      # @param [String] req_path the path part of request url
      # @param [String] req_method the method of request
      #
      # @return [Boolean] true if the route match for the provided params
      def match?(req_path, req_method)
        parts = Router.url_parts(req_path)
        method.match?(req_method) &&
          version.match?(parts[:version]) &&
          path.match?(parts[:segments].join("/"))
      end

      def ==(other)
        other.class == self.class && other.raw_value == raw_value
      end

      def <=>(other)
        path <=> other.path
      end

      def raw_value
        [path, method, handler].map(&:raw_value)
      end

      def segment_count
        path.segment_count
      end

      def operation_id?(op_id)
        operation_id == op_id
      end

      def to_url(*args)
        path.to_url(version, *args)
      end
    end
  end
end