include Java

import javax.management.DynamicMBean
import javax.management.MBeanInfo
import javax.management.ObjectName
import javax.management.remote.JMXServiceURL
import javax.management.remote.JMXConnectorServerFactory

class ObjectName
  def [](key)
    get_key_property(key.to_s)
  end
end

module javax::management::openmbean::CompositeData
  include Enumerable

  def [](key)
    get(key.to_s)
  end

  def each
    get_composite_type.key_set.each { |key| yield key }
  end

  def each_pair
    get_composite_type.key_set.each { |key| yield key, get(key) }
  end
end

module JMX
  # Holder for beans created from retrieval (namespace protection [tm])
  module MBeans
  end

  class MBeanProxy
    def self.generate(server, object_name)
      class_name = object_name[:type]

      # Hmmm, I guess type is not everywhere
      return nil unless class_name
      return nil if class_name =~ /^([a-z_-])/

      parent = object_name.domain.split(".").inject(MBeans) do |parent, segment|
        segment.capitalize!
        new_parent = unless parent.const_defined? segment
          parent.const_set segment, Module.new
        else
          parent.const_get segment
        end
      end

      if parent.const_defined? class_name
        return parent.const_get(class_name).new(server, object_name)
      end

      proxy = Class.new MBeanProxy

      parent.const_set class_name, proxy

      proxy.new(server, object_name)
    end

    def initialize(server, object_name)
      @server, @object_name = server, object_name

      define_operations
    end

    def [](name)
      @server.getAttribute @object_name, name.to_s
    end

    def []=(name, value)
      @server.setAttribute @object_name, Attribute.new(name, value)
    end

    def add_notification_listener(listener, *rest)
      filter, handback = *rest
      @server.addNotificationListener @object_name, listener, filter, handback
    end

    def emove_notification_listener(listener)
      @server.removeNotificationListener @object_name, listener
    end

    def method_missing(name, *args)
      java_args = java_args(args)
      @server.invoke @object_name, name.to_s, java_args, java_types(java_args)
    end

    def inspect

    end

    private

    def define_operations
      @server.getMBeanInfo(@object_name).operations.each do |op|
        self.class.__send__(:define_method, op.name) do |*args|
          java_args = java_args(args)
          @server.invoke @object_name, op.name, java_args, java_types(java_args)
        end
      end
    end

    def java_args(params)
      return nil if params.nil?

      params.to_java(:string)
    end

    def java_types(params)
      return nil if params.nil?

      params.map {|e| Java.ruby_to_java(e).java_class.name }.to_java(:string)
    end
  end

  class MBeanServerConnector
    def initialize(location, server)
      @url = JMXServiceURL.new location
      @server = JMXConnectorServerFactory.newJMXConnectorServer @url, nil, server.server

      if block_given?
	start
        yield
        stop
      end
    end

    def active?
      @server.isActive
    end

    def start
      @server.start
    end

    def stop
      @server.stop if active?
    end
  end

  # Represents both MBeanServer and MBeanServerConnection
  class MBeanServer
    import javax.management.remote.JMXConnectorFactory
    import javax.management.MBeanServerFactory
    import javax.management.Attribute

    attr_accessor :server
    @@classes = {}

    def initialize(location=nil, username=nil, password=nil)
      if (location)
        env = username ?
          {"jmx.remote.credentials" => [username, password].to_java(:string)} :
          nil
        url = JMXServiceURL.new location
        @server = JMXConnectorFactory.connect(url, env).getMBeanServerConnection
      else
        @server = MBeanServerFactory.createMBeanServer
      end
    end

    def [](object_name)
      name = make_object_name object_name

      unless @server.isRegistered(name)
        raise NoSuchBeanError.new("No name: #{object_name}")
      end

      @server.getObjectInstance name
      MBeanProxy.generate(@server, name)
    end

    def []=(class_name, object_name)
      name = make_object_name object_name

      @server.createMBean class_name, name, nil, nil

      MBeanProxy.generate(@server, name)
    end

    def default_domain
      @server.getDefaultDomain
    end

    def domains
      @server.domains
    end

    def mbean_count
      @server.getMBeanCount
    end

    def query_names(name=nil, query=nil)
      name = make_object_name name
      @server.queryNames(name, query)
    end

    def register_mbean(object, object_name)
      name = make_object_name object_name

      @server.registerMBean(object, name)

      MBeanProxy.generate(@server, name)
    end

    private

    def make_object_name(object_name)
      return object_name if object_name.kind_of? ObjectName

      ObjectName.new object_name
    rescue
      raise ArgumentError.new("Invalid ObjectName #{$!.message}")
    end
  end

  class NoSuchBeanError < RuntimeError
  end
end

class RubyDynamicMBean
  include DynamicMBean

  def initialize(name, description)
    @info = MBeanInfo.new name, description, nil, nil, nil, nil
    @name, @description = name, description
  end

  def getAttribute(attribute); $stderr.puts "getAttribute"; end
  def getAttributes(attributes); $stderr.puts "getAttributes"; end
  def getMBeanInfo; $stderr.puts "getMBeanInfo"; @info; end
  def invoke(actionName, params=nil, signature=nil);
    send(actionName, *params)
  end
  def setAttribute(attribute); $stderr.puts "setAttribute"; end
  def setAttributes(attributes); $stderr.puts "setAttributes";  end
  def to_s; "#@name: #@description"; end
  def inspect; "#@name: #@description"; end
  def toString; "#@name: #@description"; end
end