require 'hashie'

module VK
  module Resolver
    NAMESPACES = ['users', 'friends']

    def method_missing(method_name, *args, &block)
      method_name = method_name.to_s

      if NAMESPACES.include?(method_name)
        # called from Client
        Namespace.new(method_name, resolver: resolver)
      else
        # called from Namespace or one-level method
        Method.new(method_name, resolver: resolver).call(args.first || {}, &block)
      end
    end

  private
    def resolver
      Hashie::Mash.new(name: @name, token: token)
    end
  end

  class Client
    include Resolver

    attr_reader :token

    def initialize(token = nil)
      @token = token
    end
  end

  module Resolvable
    attr_reader :name

    def initialize(name, options = {})
      @name     = name
      @resolver = options.delete(:resolver)
    end

    def token
      @resolver.token
    end
  end

  class Namespace
    include Resolvable
    include Resolver
  end

  class Method
    include Resolvable

    def call(args = {}, &block)
      # response = API.call(full_name, args, token)
      # Result.process(response, type, block)
      [full_name, args, token]
    end

  private
    def full_name
      [@resolver.name, @name].compact.map(&:to_s).join('.')
    end

    def type
      @name =~ PREDICATE_NAMES ? :boolean : :anything
    end
  end
end

p VK::Client.new.users.get(uid: 1)
p VK::Client.new.get_profiles(token: 'trololo')
p VK::Client.new('trololo').friends.get_by_id(uids: [1, 2, 3])