package bluej.stride.framedjava.frames;

import java.util.List;
import java.util.stream.Stream;

import bluej.stride.slots.EditableSlot;
import javafx.beans.binding.BooleanExpression;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Cursor;
import bluej.stride.framedjava.ast.ExpressionSlotFragment;
import bluej.stride.framedjava.ast.HighlightedBreakpoint;
import bluej.stride.framedjava.canvases.JavaCanvas;
import bluej.stride.framedjava.elements.ReturnElement;
import bluej.stride.framedjava.slots.OptionalExpressionSlot;
import bluej.stride.generic.Frame;
import bluej.stride.generic.FrameCanvas;
import bluej.stride.generic.FrameFactory;
import bluej.stride.generic.InteractionManager;
import bluej.stride.generic.SingleLineFrame;
import bluej.stride.operations.FrameOperation;
import bluej.stride.slots.HeaderItem;
import bluej.stride.slots.SlotLabel;
import bluej.utility.javafx.FXRunnable;
import bluej.utility.javafx.JavaFXUtil;




| A return statement
| @author Fraser McKay
|
public class ReturnFrame extends SingleLineFrame
 
implements CodeFrame<ReturnElement>, DebuggableFrame{    
   private final OptionalExpressionSlot value;
   
   private ReturnElement element;
   
   private final SimpleStringProperty returnType = new SimpleStringProperty();
   
   private final SimpleBooleanProperty showingValue = new SimpleBooleanProperty(true);
    
   
   
   private final BooleanExpression notShowingValue = showingValue.not();
    
   
   


| Default constructor.
| @param editor
|
private ReturnFrame(InteractionManager editor)
   {
      super(editor, "return", "return-");
        
       
      SlotLabel spacer = new SlotLabel(" ");
      spacer.setOpacity(0.0);
      spacer.setCursor(Cursor.TEXT);
       
      
      value = new OptionalExpressionSlot(editor, this, this, getHeaderRow(), "return-");
      value.setSimplePromptText("expression");
      value.bindTargetType(returnType);

      JavaFXUtil.addChangeListener(showingValue, showing -> {
      if (!showing)
      value.cleanup();         
      });
   spacer.setOnMouseClicked(e -> {
   showingValue.set(true);
   value.requestFocus();
   e.consume();         
   });
getHeaderRow().bindContentsConcat(FXCollections.<ObservableList<? extends HeaderItem>>observableArrayList(
FXCollections.observableArrayList(headerCaptionLabel),
JavaFXUtil.listBool(notShowingValue, spacer),
JavaFXUtil.listBool(showingValue, value),
FXCollections.observableArrayList(previewSemi)
       
));
        
       

value.onLostFocus(() -> {
if ("void".equals(returnType.get()) && value.getText().isEmpty())
showingValue.set(false);         
} );
}
    
   
public ReturnFrame(InteractionManager editor, ExpressionSlotFragment val, boolean enabled)
   {
   this(editor);
   if (val != null)
       {
      showingValue.set(true);
      value.setText(val);         
      }
       

   else
       {
      showingValue.set(false);         
      }
   frameEnabledProperty.set(enabled);     
   }

   
@Override
   
public void regenerateCode()
   {        
   
   
   
   
   final boolean generateReturnValue = showingValue.get() && (!value.getText().isEmpty() || value.isCurrentlyCompleting());
       
   element = new ReturnElement(this, generateReturnValue ? value.getSlotElement() : null, frameEnabledProperty.get());     
   }
    
   
@Override
   
public ReturnElement getCode()
   {        
   return element;     
   }
    
   
public static FrameFactory getFactory()
   {        
   return new FrameFactory<ReturnFrame>() {            
      @Override
           
      public ReturnFrame createBlock(InteractionManager editor)
           {                
         return new ReturnFrame(editor);             
         }
                        
           
      @Override 
           
      public Class getBlockClass()
           {                
         return ReturnFrame.class;             
         }         
      };
   }

   
@Override
   
public void updateAppearance(FrameCanvas parentCanvas)
   {
   super.updateAppearance(parentCanvas);
       
   
   for (Frame f = parentCanvas == null ? null : parentCanvas.getParent().getFrame(); f != null; f = f.getParentCanvas() == null ? null : f.getParentCanvas().getParent().getFrame())
       {
      if (f instanceof NormalMethodFrame)
           {
         NormalMethodFrame mf = (NormalMethodFrame)f;
         returnType.unbind();
         returnType.bind(mf.returnTypeProperty());
               
         
         if (!"void".equals(returnType.get()))
         showingValue.set(true);
               
         return;             
         }         
      }
        
       
   
   returnType.unbind();
   returnType.set(null);
   showingValue.set(false);     
   }

   



public FXRunnable getRemoveFilledValueAction()
   {
   if (value.getText().equals(""))
       {
      showingValue.set(false);
           
      return null;         
      }

   else if (showingValue.get())
   return () -> showingValue.set(false);
       
   else{ return null;
      }     
   }

   
@Override
   
public Stream getPossiblyHiddenSlotsDirect()
   {
   return Stream.of(value);     
   }

   

public void showValue()
   {
   showingValue.set(true);     
   } 
}