package bluej.stride.framedjava.frames;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;

import bluej.stride.generic.Frame;
import bluej.stride.generic.FrameCanvas;
import bluej.stride.generic.FrameCursor;
import bluej.utility.Utility;
import threadchecker.OnThread;
import threadchecker.Tag;

public class FrameHelper
{   
@OnThread(Tag.FXPlatform)
   
   public static void flagErrorsAsOld(FrameCanvas canvas)
   {
      canvas.getBlockContents().forEach(f -> f.flagErrorsAsOld());     
      }

   @OnThread(Tag.FXPlatform)
   
   public static void removeOldErrors(FrameCanvas canvas)
   {
      canvas.getBlockContents().forEach(f -> f.removeOldErrors());     
      }

   p.public static void pullUpContents(Frame f, FrameCanvas innerCanvas)
   {        
      
      FrameCursor cursorBefore = f.getCursorBefore();
       
      
      ArrayList<Frame> contents = new ArrayList<>(innerCanvas.getBlockContents());
      contents.forEach(c -> innerCanvas.removeBlock(c));
      cursorBefore.insertFramesAfter(contents);
      f.getParentCanvas().removeBlock(f);     
      }

   
   public static void processVarScopesAfter(FrameCanvas parentCanvas,
           
   Frame afterFrame, BiConsumer<Map<String, List<Frame>> 
| scopes, excluding cur
|
Frame 
| cur
|
process)
   {        
      processVarScopesAfter(parentCanvas, afterFrame, new HashMap<>(), process);     
      }
        
   
   private static void processVarScopesAfter(FrameCanvas parentCanvas,
               
   Frame afterFrame, Map<String, List<Frame>> parentVars, BiConsumer<Map<String, List<Frame>> 
| scopes, excluding cur
|
Frame 
| cur
|
process)
   {        
      
      Map<String, List<Frame>> vars = new HashMap<>(parentVars);
       
      for (Frame f : Utility.iterableStream(parentCanvas.getFramesAfter(afterFrame)))
       {
         process.accept(vars, f);
            
           
         for (FrameCanvas c : Utility.iterableStream(f.getCanvases()))
           {                
            Map<String, List<Frame>> extraVarsWithin = new HashMap<>();
               
            for (String v : f.getDeclaredVariablesWithin(c))
               {
               extraVarsWithin.put(v, Arrays.asList(f));                 
               }
            Map<String, List<Frame>> varsInside = Utility.mergeMaps(vars, extraVarsWithin, Utility::concat);
            processVarScopesAfter(c, null, varsInside, process);             
            }
            
           
         for (String var : f.getDeclaredVariablesAfter())
           {                
            vars.merge(var, new ArrayList<Frame>(Arrays.asList(f)), Utility::concat);             
            }         
         }     
      } 
   }