package bluej.stride.framedjava.slots;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import bluej.stride.framedjava.ast.links.PossibleTypeLink;
import bluej.stride.generic.InteractionManager;
import bluej.utility.javafx.FXBiConsumer;
import bluej.utility.javafx.FXConsumer;




| Created by neil on 22/05/2016.
|
public class InfixType extends InfixStructured<TypeSlot, InfixType>{    
   private InfixType(InteractionManager editor, TypeSlot slot, String initialContent, BracketedStructured wrapper, StructuredSlot.ModificationToken token, Character... closingChars)
   {
      super(editor, slot, initialContent, wrapper, token, closingChars);     
      }

   InfixType(InteractionManager editor, TypeSlot slot, StructuredSlot.ModificationToken token)
   {
      super(editor, slot, token);     
      }
   
   
   
| Is this string an operator
|
@Override
   p.public boolean isOperator(String s)
   {
      switch (s)
       {            
         case ".": case ",":
           
         return true;
           
         default:
               
         return false;         
         }     
      }

   
   

| Does the given character form a one-character operator, or begin a multi-character operator
|
@Override
   p.public boolean beginsOperator(char c)
   {
      switch (c)
       {            
         case ',': case '.':
           
         return true;
           
         default:
               
         return false;         
         }     
      }

   
   @Override
   p.public boolean canBeUnary(String s)
   {        
      
      return false;     
      }

   
   @Override
   
   protected boolean isOpeningBracket(char c)
   {        
      return c == '<' || c == '[';     
      }

   
   @Override
   
   protected boolean isClosingBracket(char c)
   {        
      return c == '>' || c == ']';     
      }

   
   @Override
   
   protected boolean isDisallowed(char c)
   {
      return !(Character.isJavaIdentifierStart(c) || Character.isJavaIdentifierPart(c)
           
      || c == ',' || c == '.' || c == '<' || c == '>' || c == '?'
      || c == '[' || c == ']' || c == '$');     
      }

   
   @Override
   p.public InfixType newInfix(InteractionManager editor, TypeSlot slot, String initialContent, BracketedStructured wrapper, StructuredSlot.ModificationToken token, Character... closingChars)
   {        
      return new InfixType(editor, slot, initialContent, wrapper, token, closingChars);     
      }

   
   @Override
   
   public void calculateTooltipFor(StructuredSlotField expressionSlotField, FXConsumer<String> handler)
   {        
           
      }

   void runIfCommaDirect(FXBiConsumer<String, String> listener)
   {
      Optional<Integer> optIndex = operators.findFirst(op -> op != null && op.get().equals(","));
      optIndex.ifPresent(index -> {
           
      
      String before = getCopyText(null, new CaretPos(index, fields.get(index).getEndPos()));
           
      String after = getCopyText(new CaretPos(index + 1, new CaretPos(0, null)), null);
      listener.accept(before, after);         
      });
   }

   
public List findTypeLinks()
   {        
   List<PossibleTypeLink> links = new ArrayList<>();

       
   int startField = 0;
       
   StringBuilder type = new StringBuilder(fields.get(0).getCopyText(null, null));
        
       
   
   for (int i = 1; i <= fields.size(); i++)
       {
      if (i - 1 >= operators.size() || operators.get(i - 1) == null || !operators.get(i - 1).get().equals("."))
           {                
         int start = slot.getTopLevel().caretPosToStringPos(absolutePos(new CaretPos(startField, fields.get(startField).getStartPos())), false);
               
         int end = slot.getTopLevel().caretPosToStringPos(absolutePos(new CaretPos(i - 1, fields.get(i - 1).getEndPos())), false);
         if (start != end && type.length() > 0)
                   
         links.add(new PossibleTypeLink(type.toString(), start, end, slot));
               
         type = new StringBuilder();
               
         startField = i;             
         }
           

      else
           {
         type.append(operators.get(i - 1).get());             
         }
      if (i >= fields.size())
               
      break;
            
      if (fields.get(i) instanceof BracketedStructured)
           {
         links.addAll(((BracketedStructured<InfixType, TypeSlot>)fields.get(i)).getContent().findTypeLinks());             
         }
           

      else
           {
         type.append(fields.get(i).getCopyText(null, null));             
         }         
      }

       
   return links;     
   }

   
@Override
   
protected boolean supportsFloatLiterals()
   {        
   return false;     
   } 
}