#   The contents of this file are subject to the Mozilla Public License
#   Version 1.1 (the "License"); you may not use this file except in
#   compliance with the License. You may obtain a copy of the License at
#   http://www.mozilla.org/MPL/
#
#   Software distributed under the License is distributed on an "AS IS"
#   basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
#   License for the specific language governing rights and limitations
#   under the License.
#
#   The Initial Developer of the Original Code is Johannes Rudolph.
#   Portions created by the Initial Developer are Copyright (C) 2006
#   the Initial Developer. All Rights Reserved.
#
#   Contributor(s):
#      Johannes Rudolph <johannes_rudolph@gmail.com>

require 'java'

module SWT
  def self.object_tree(o)
    require 'apps/objecttree'
    JRubyUtils::RubyObjectBrowser.object_tree o
  end
  class TreeCommand
    def initialize(parent)
      @parent=parent
    end
    def accept(child)
      child
    end
    def stacktrace
      "in #{self.class}\n#{@parent.stacktrace if @parent}"
    end
  end
  class SimpleCommand<TreeCommand
    def initialize(parent,child=nil)
      super(parent)
      @child=child
    end
    def accept(child)
      @child=child
    end
    def invoke(tree)
      @child=@child.call if @child.is_a? Proc
      raise "Link expression must evaluate to command: #{stacktrace}" unless @child
      tree=[tree] unless tree.is_a? Array
      @child.invoke tree
    end
    def to_s
      "#{self.class} (#{@child})"
    end
  end
  class ContainerTreeCommand<TreeCommand
    def initialize(parent)
      super(parent)
      @children=[]
    end
    def accept(child)
      @children << child
      child
    end
    def invoke(stack)
      @children.each { |x| x.invoke stack}
    end
    def to_s
      "#{self.class} ([#{@children.join ','}])"
    end
  end
  class ChildCommand<ContainerTreeCommand
    include_class 'org.eclipse.swt.widgets.TreeItem'
    include_class 'org.eclipse.swt.widgets.Tree'
    include_class 'org.eclipse.swt.events.TreeListener'
    def initialize(parent)
      super(parent)
    end

    def invoke(origstack)
      stack=origstack.dup
      last=origstack.last
      expand=lambda do
        res=TreeItem.new last,Builder::RealSWT::NONE
        res.setData("object",last.getData("object"))
        #puts "In Child.invoke: res:#{res.hashCode} data: #{last.getData("object").id}"
        stack.push(res)

        #puts "Stack: #{stack} last:#{stack.last.hashCode} objectid:#{stack.last.getData("object").hashCode}"
        @children.each do |x|
          x.invoke stack
        end
        stack.pop
        res
      end

      parent=origstack.last

      unless parent.is_a? TreeItem
        expand.call
        return
      end

      dummy=parent.getData("dummy")
      unless dummy
        dummy=TreeItem.new parent,Builder::RealSWT::NONE
        dummy.setText "dummy"
        parent.setData("dummy",dummy)
      end

      li=TreeListener.new
      class <<li
        def treeExpanded(e)
          @block.call e
        end
        def treeCollapsed(e)
        end
        def set_info(&block)
          @block=block
        end
      end
      li.set_info do |e|
        if e.item==parent
          unless dummy.isDisposed
            dummy.dispose
          end

          res=expand.call
          e.widget.getColumn(0).pack if e.widget.getColumnCount>0
          res.getParent.removeTreeListener li
        end
      end
      parent.getParent.addTreeListener li
    end
  end
  class LabelCommand<TreeCommand
    def initialize(parent,exp,index=0)
      super(parent)
      @exp=exp
      @index=index
    end
    def invoke(stack)
      stack.last.setText(@index,@exp.call(stack.last.getData("object")).to_s)
    end
    def to_s
      "LabelCmd (#{@exp})"
    end
  end
  class ImageCommand<TreeCommand
    include_class 'org.eclipse.swt.graphics.Image'
    def initialize(parent,exp)
      super(parent)
      @exp=exp
    end
    def invoke(stack)
      image=@exp.call stack.last.getData("object")
      image=Image.new stack.last.getDisplay, image if image.is_a? String
      raise "Image expression(#{image},#{@exp}) must be an swt image or a filename: #{stacktrace}" unless image.is_a? Image
      stack.last.setImage(image)

    end
  end
  class ObjectCommand<TreeCommand
    def initialize(parent,exp)
      super(parent)
      @exp=exp
    end
    def invoke(stack)
      lastobject=stack.last.getData("object")
      #puts "Laststack: #{stack.last} id: #{stack.last.hashCode} object: #{lastobject} id: #{lastobject.hashCode}"
      newobject=@exp.call(lastobject)
      #class <<newobject
      #  def last
      #    @last
      #  end
      #  def last=(last)
      #    @last=last
      #  end
      #  alias :old_dup :dup
      #  def dup
      #    new=old_dup
      #    new.last=@last
      #    puts "Object gets dupd: #{self} #{self.id}"
      #  end
      #end
      #newobject.last=lastobject
      #test=Java.java_to_ruby(newobject)
      stack.last.setData("object",newobject)
      #test2=stack.last.getData("object")
      #puts "Test: #{test}, Test2: #{test2} test1==test2: #{test==test2} test1===test2 #{test===test2} id:#{test.id} lasttree: #{stack.last.hashCode}"
#     puts "ObjectCommand.invoke lastobject: #{lastobject} newobject: #{newobject} newobject.last: #{newobject.last}"
    end
  end
  class ChildrenCommand<ContainerTreeCommand
    def accept(cmd)
      @inner.accept cmd
    end
    def initialize(parent,exp)
      super(parent)
      @exp=exp
      @inner=ContainerTreeCommand.new self
    end
    def invoke(stack)
      last=stack.last.getData("object")
      coll=@exp.call(last)
      coll.each do |x|
        cmd=ChildCommand.new self
        @children << cmd
        cmd.accept(ObjectCommand.new(self,lambda{last}))
        cmd.accept(ObjectCommand.new(self,lambda{x}))
        cmd.accept(@inner)
        cmd.invoke stack
      end
    end
  end
  class ConditionalCommand<ContainerTreeCommand
    def initialize(parent,exp)
      super(parent)
      @exp=exp
    end
    def invoke(stack)
      condition=@exp.call stack.last.getData("object")
      super if condition
    end
  end
  class TreeBuilder
    def initialize(&block)
      @current=ContainerTreeCommand.new nil
      instance_eval(&block)
    end
    def column(text)
      cmd=SimpleCommand.new @current
      @current.accept cmd
      class <<cmd
        include_class 'org.eclipse.swt.widgets.TreeColumn'
        def invoke(stack)
#          puts "column invoke stack:#{stack}, name:#{@name}"
          stack.last.setHeaderVisible true
          tc=TreeColumn.new stack.last,Builder::RealSWT::NONE
          tc.setText @name
          tc.pack
        end
        def name=(name)
          @name=name
        end
      end
      cmd.name=text
    end
    def child(label=nil,&block)
      cmd=ChildCommand.new @current
      @current and @current.accept cmd
      old=@current
      @current=cmd
      label(label) if label
      instance_eval(&block) if block
      @current=old
      cmd
    end
    def cell(i,&block)
      @current.accept(LabelCommand.new(@current,block,i))
    end
    def label(labelExp=nil,&block)
      block=lambda{labelExp} if labelExp
      @current.accept(LabelCommand.new(@current,block))
    end
    def object(&block)
      @current.accept(ObjectCommand.new(@current,block))
    end
    def image(&block)
      @current.accept(ImageCommand.new(@current,block))
    end
    def link(cmd=nil,&block)
      cmd=block unless cmd
      #puts "Creating link with cmd=#{cmd}"
      @current.accept(SimpleCommand.new(@current, cmd))
    end
    def children(exp,&block)
      cmd=ChildrenCommand.new @current,exp
      @current.accept cmd
      old=@current
      @current=cmd
      instance_eval(&block) if block
      @current=old
      cmd
    end
    def leaf(&block)
      child do
        label &block
      end
    end
    def container(&block)
      cmd=ContainerTreeCommand.new @current
      @current and @current.accept cmd
      old=@current
      @current=cmd
      instance_eval(&block)if block
      @current=old
      cmd
    end
    def conditional(exp,&block)
      cmd=ConditionalCommand.new @current,exp
      @current.accept cmd
      old=@current
      @current=cmd
      instance_eval(&block) if block
      @current=old
      cmd
    end
    def run(tree)
      @current.invoke [tree]
    end
    def current
      @current
    end
  end
  class Builder
    #class <<self
    #  alias :old_include_class :include_class
    #def include_class (name,&block)
    #  cl=old_include_class name,&block
    #  JavaUtilities.get_proxy_class(name).compile
    #end
    #end

    include_class 'org.eclipse.swt.widgets.Shell'
    include_class 'org.eclipse.swt.widgets.Group'
    include_class 'org.eclipse.swt.widgets.Text'
    include_class 'org.eclipse.swt.widgets.Label'
    include_class 'org.eclipse.swt.widgets.Button'
    include_class 'org.eclipse.swt.widgets.Tree'
    include_class 'org.eclipse.swt.widgets.Composite'
    include_class 'org.eclipse.swt.widgets.Display'
    include_class 'org.eclipse.swt.layout.GridLayout'
    include_class 'org.eclipse.swt.layout.FillLayout'
    include_class 'org.eclipse.swt.layout.GridData'
    include_class 'org.eclipse.swt.SWT' do
      'RealSWT'
    end

 #   def initialize#(&block)

#    end

    def self.go(&block)
      shell=Builder.new.instance_eval(&block)
      shell.pack
      shell.layout
      shell.open
      run shell
    end

    def init_control(c,opts={})
      if c.getParent.getLayout.class==GridLayout
        gd=GridData.new
        opts[:colspan] and gd.horizontalSpan=opts[:colspan]
        if opts[:verticalFill]
          gd.verticalAlignment=RealSWT::FILL
          gd.grabExcessVerticalSpace=true
        end
        if opts[:horizontalFill]
          gd.horizontalAlignment=RealSWT::FILL
          gd.grabExcessHorizontalSpace=true
        end
        c.setLayoutData(gd)
      end
    end
    def init_composite(c,columns,opts={},&block)
      init_control c,opts
      gl=GridLayout.new
      gl.numColumns=columns
      c.setLayout(gl)

      if block_given?
        oldparent=@parent
        @parent=c
        instance_eval(&block)
        @parent=oldparent
      end
    end

    def shell(title,columns=1,style=RealSWT::SHELL_TRIM,&block)
      res=Shell.new(Display.getDefault,style)
      res.setText title
      fl=FillLayout.new
      fl.marginHeight=5
      fl.marginWidth=5
      res.setLayout fl
#      oldparent=@parent
      @parent=res
#      instance_eval(&block) if block_given?
#      @parent=oldparent
      container(columns,&block)
      #init_composite res,columns
      return res
    end

    def container(columns=1,opts={},&block)
      opts[:style] or opts[:style]=RealSWT::NONE
      res=Composite.new(@parent,opts[:style])
      init_composite res,columns,opts,&block
      return res
    end

    def group(title,columns=1,style=RealSWT::NONE,&block)
      res=Group.new(@parent,style)
      res.setText title
      init_composite res,columns,&block
      return res
    end

    def text(text=nil,style=RealSWT::BORDER)
      #puts "Text: #{text}"
      res=Text.new(@parent,style)
      text and res.setText text
      init_control res
      return res
    end

    def label(text,style=RealSWT::NONE)
      res=Label.new(@parent,style)
      res.setText text
      init_control res
      return res
    end

    def button(text,style=RealSWT::NONE)
      res=Button.new(@parent,style)
      res.setText text
      init_control res
      return res
    end

    def tree(opts={:style=>RealSWT::BORDER},&block)
      opts[:style] or opts[:style]=RealSWT::BORDER
      res=Tree.new(@parent,opts[:style])
      init_control res,opts
      builder=TreeBuilder.new &block
      #puts builder.current
      builder.run res
      res.pack
      return res
    end

    unless Builder.methods.include? :method_missing
      alias :old_method_missing method_missing
    end

    def method_missing(id,*args)
      #puts "ID:#{id.class.inspect}\t\targs:#{args.join ','}\t#{id=~/labeled(\w+)/}"
      if id.to_s=~/labeled(\w+)/
        label args.shift
        method($1.downcase).call *args
      else
        old_method_missing id,args
      end
    end

    def Builder.run(shell)
      d=shell.getDisplay
      while(!shell.isDisposed&&shell.isVisible) do
        while(d.readAndDispatch) do end
        d.sleep
      end
    end
  end
end