# Copyright 2003-2004 Kevin Reid.
# This source code and related files are distributed under the MIT License, as described in the document named "License.txt" which should be provided with this source distribution.

pragma.enable("explicit-result-guard")
pragma.disable("easy-return")

pragma.enable("accumulator")

def <den>                    := <import:org.cubik.den.*>
def <swing>                  := <import:javax.swing.*>

def lazy                     := <den:util.lazy>

def JPanel__quasiParser      := lazy(fn{ <import:org.erights.ex.swing.JPanel__quasiParser> })
def action                   := lazy(fn{ <den:util.action> })
def description__quasiParser := lazy(fn{ <den:util.description__quasiParser> })
def makeInteriorBehavior     := lazy(fn{ <den:behavior.makeInteriorBehavior> })
def makeLamportSlot          := <elib:slot.makeLamportSlot>
def makeThing                := lazy(fn{ <den:makeThing> })
def name__quasiParser        := <den:util.name.name_en__quasiParser>
def setupComponentReactor    := <den:util.swing.setupComponentReactor>

def makeBox {
  to __optUncall() :any { return [<import>, "get", [meta.context().getFQNPrefix().split("$")[0]]] }

  to run([
    => self := (def superArgs; def box; box), 
    "super" => optSuper := null,
    "open" => initOpen := false
  ] | bind superArgs) :any {
    #superArgs["owner"].trace("loop_debug_1", `makeBox.run`)
  
    def &open := makeLamportSlot(boolean, initOpen)
  
    def outerSuper := if (optSuper != null) { optSuper } else {
      makeThing([=> self] | superArgs | ["name" => name`a box`]) 
    }
  
    bind box extends outerSuper {
      to __optUncall() :any {
        [makeBox, "run", [[=> self, => super, => open]]]
      }

      to __conformTo(guard) :any {
        if (guard.__respondsTo("isDenDetailGuard", 0) && guard.isDenDetailGuard()) {
          def outerPanel
          
          def openBox := <swing:makeJCheckBox>("Open")

          setupComponentReactor(openBox, self.getOpenReporter(), def detailUpdateIsOpen(newValue) :void {
            openBox.setSelected(newValue)
          }, null)
          action(openBox, fn{
            self.setOpen(openBox.isSelected())
            null
          })

          bind outerPanel := JPanel`
            ${guard.sprout().coerce(super).getComponent()}.X.Y
            $openBox
          `
          
          def detail {
            to isDenDetail() :any { true }
            to getComponent() :any { outerPanel }
          }
        } else {
          box
        }
      }

      to getOpen() :any { open }
      to setOpen(new :boolean) :any { open := new }
      to getOpenReporter() :any { (&open).readOnly() }

      to getContentsInterior() :any { self.getBehaviors()["inside"].getInterior() }
      to getTopInterior() :any { self.getBehaviors()["top"].getInterior() }

      to interact_setOpen([[inModes, outModes], optAllegedActor], newValue, optEvent) :void {
        require(inModes.contains("touch"))

        if (newValue != open) {
          def loc := self.getExterior().getLocation()
          def event := if (optEvent != null) {
            loc <- getEventGuard() <- coerce(optEvent)
          } else {
            loc <- makeEvent()
          }

          def selfId := self.getIdentityHolder().getIdentity()
          when (event, self.getIdentityHolder().makeAssertions(event, [
            "org.cubik.den.eventDescription" => if (newValue){
              description`%?(en:$optAllegedActor:I; %!:(opens) $selfId:d;.%|jbo:$selfId:i; kalri zu'e $optAllegedActor:i;%)`
            } else {
              description`%?(en:$optAllegedActor:I; %!:(closes) $selfId:d;.%|jbo:$selfId:i; ganlo zu'e $optAllegedActor:i;%)`
            }
          ])) -> done(_, _) :void {
            self.setOpen(newValue)
            event <- send()
          } catch p {
            throw(p)
          }
        } else {
          throw("no change")
        }
      }
      
      to exterior_getOptCommandImplementation(cmd :List) :any {
        # NOTE: Yes, this is awful. I'll clean it up after some more experience with commands.
      
        def selfId := self.getIdentityHolder().getIdentity()
        if (cmd =~ [[`string`, verb ? ["open", "close"].contains(verb)], [`thing`, ==selfId]]) {
          def openImpl(contextBox, from, [[`string`, verb ? ["open", "close"].contains(verb)], [`thing`, ==selfId]]) :vow[void] {
            when (from.getRcvr() <- getCommandContextUnsealer() <- unseal(contextBox)) -> done(context) :void {
              
              def toOpen := verb == "open"
              
              if (toOpen != open) {
                self.interact_setOpen([[["touch"], []], from], toOpen, null)
              } else {
                def existingState := open.pick(description`%?(en:open%|jbo:kalri%)`, description`%?(en:closed%|jbo:ganlo%)`)
                context <- getMsgOutputFunc() <- (description`%?(en:$selfId:D; %!:(is/are) already $existingState..$\n%|.i $selfId:n; $existingState.%)`)
              }
            } catch p {
              throw(p) 
            }
          }
        }
      }
            
    }

    #superArgs["owner"].trace("loop_debug_1", `checking behaviors`)
    
    # fixme: replace makeBox with a suitable
    if (__equalizer.sameYet(self.getBehaviors(), [].asMap())) {
      #superArgs["owner"].trace("loop_debug_1", `adding behaviors`)
      def topB := makeInteriorBehavior(
        self.addBehavior("top", topB),
        "lookContentsHeaderDesc" => description`%?(en:On top:%|jbo:.i ko'a se cpana ge%)`,
        "lookOpenDesc" => description``,
      )
      def insideB := makeInteriorBehavior(self.addBehavior("inside", insideB), "openSlot" => &open)
    }
    
    #superArgs["owner"].trace("loop_debug_1", `returning`)
    box
  }
}

? def makeBox := <import:org.cubik.den.thing.makeBox>
# value: <makeBox>

?# fixme: more updoc