// TODO: different sorting methods, e.g. "widest SSIs"
// Note: Blur is slow. e.g. 48ms for 2 screens
// Posterization is fast, e.g. 8ms for 2 screens
// Region making speed depends on how many regions there are.
// TODO: Make regions incrementally by starting at random pixels
sclass G22DataWrangler > Stages2 is IHasChangeListeners {
  replace Stage with Runnable.
  
  event change;
  
  settable BufferedImage inputImage;
  
  // try to re-use anything that is identical
  settable G22DataWrangler stealingFrom;
  
  settable bool withDiagonals = true;
  settableWithVar int blur = 0; // in pixels
  
  settableWithVar int colorsPerChannel = 2;
  
  settableWithVar float drift; // brightness drift for gradients (-1 to 1)
  settableWithVar float antiDrift; // brightness drift after rposterization gradients (-1 to 1)
  
  // kilobytes per compressed image (pessimistic estimate
  // counting 2 bytes for each int)
  settable TargetAndActual<Double> kilobytes = new(250.0);
  settable new TargetAndActual<Double> coveredPixelsPercentage;
  settable new TargetAndActual<Double> detailLevel;
  
  settable bool vectorize = true;
  settable bool allowPartialSSIs = true;
  
  gettable bool blackAndWhiteMode;
  
  settable SortMode sortMode = SortMode.compressibility;
  
  enum SortMode { compressibility, pixels }
  
  BufferedImage blurredImage;
  int maxLines, maxInts;
  L<? extends AbstractSSI> currentSSIs; // ssis at current stage
  L<SSI> initialSSIs;
  AbstractSSIList sortedSSIs, cutSSIs,
    vectorizedSSIs, cutVectorizedSSIs;
  CutListToBudget<AbstractSSI> cutter;
  
  // We store the posterized image as Hi15
  Hi15Image posterizedImage;
  
  // Region maker + regions
  
  FastRegions_Hi15Image regionMaker;
  L<IImageRegion<Hi15Image>> regions, regionsBySize;
  
  // Constructors
  
  *() {}
  *(BufferedImage *inputImage) {}
  *(MakesBufferedImage inputImage) { this.inputImage = inputImage.getBufferedImage(); }
  
  // Methods
  
  SinglePixelPosterizer posterizer() {
    ret new SinglePixelPosterizer(colorsPerChannel()).drift(drift).antiDrift(antiDrift);
  }
  
  selfType kb(TargetAndActual<Double> kb) { ret kilobytes(kb); }
  TargetAndActual<Double> kb() { ret kilobytes; }
  
  WidthAndHeight resolution() {
    ret imageSize(inputImage);
  }

  double detailDivisor() {
    ret areaRoot(inputImage);
  }
  
  int colors() {
    ret blackAndWhiteMode ? 2 : cubed(colorsPerChannel());
  }
  
  transient simplyCached FieldVar<Int> varColors() {
    ret new FieldVar<Int>(this, "colors", l0 colors, l1 colors);
  }
  
  // choose number of colors for posterized image
  selfType colors(int colors) {
    int perChannel = iceil(cbrt(colors));
    blackAndWhiteMode = colors == 2;
    ret colorsPerChannel(perChannel);
  }
  
  stage "Steal" {
    if (stealingFrom != null) {
      if (stealingFrom.inputImage != inputImage)
        ret with stealingFrom = null;
        
      // Avoid keeping old data wranglers around through a stealingFrom chain
      stealingFrom.stealingFrom = null;
    }
  }

  stage "Blur" {
    if (stealingFrom != null)
      if (stealingFrom.blur == blur)
        ret with blurredImage = stealingFrom.blurredImage;
      else
        stealingFrom = null;
    blurredImage = blurBufferedImage(blur, inputImage);
  }
  
  stage posterizeStage "Posterize" {
    if (stealingFrom != null)
      if (eq(stealingFrom.posterizer(), posterizer()))
        ret with posterizedImage = stealingFrom.posterizedImage;
      else
        stealingFrom = null;
        
    var image = blurredImage;
    if (blackAndWhiteMode)
      image = BWImage(image).getBufferedImage();
      //image = transformBufferedImageWithSimplePixelOp(image, rgb -> 0xFFFFFF, ...);
    posterizedImage = posterizeBufferedImageToHi15(image, posterizer());
  }
  
  stage prepareRegionsStage "Prepare regions" {
    if (stealingFrom != null)
      if (stealingFrom.withDiagonals == withDiagonals) {
        regionMaker = stealingFrom.regionMaker;
        regions = stealingFrom.regions;
        ret;
      } else
        stealingFrom = null;
        
    regionMaker = new FastRegions_Hi15Image(posterizedImage);
    regionMaker.withDiagonals(withDiagonals);
  }
  
  stage regionsStage "Regions" {
    regions = regionMaker!;
  }
  
  stage biggestRegionsStage "Sort regions" {
    regions = regionsBySize = biggestRegionsFirst(regions);
  }
  
  stage "SSIs" {
    initialSSIs = new L;
    for (region : regions)
      initialSSIs.addAll(new G22_RegionToSSIs_v2(region).withDiagonals (withDiagonals)!);
    currentSSIs = initialSSIs;
  }
  
  int initialSSILines() {
    ret totalSSILines(initialSSIs);
  }
  
  stage "Vector-Optimize" {
    currentSSIs = vectorizedSSIs = vectorize
      ? new VectorOptimizedSSIList(currentSSIs)
      : new GeneralSSIList(currentSSIs);
  }
  
  stage "Sort SSIs" {
    if (sortMode == SortMode.compressibility)
      sortedSSIs = new GeneralSSIList(sortedDesc(currentSSIs, (a, b) -> {
        int x = cmp(a.compressibility(), b.compressibility());
        if (x != 0) ret x;
        ret cmp(a.numberOfPixels(), b.numberOfPixels());
      }));
    else if (sortMode == SortMode.pixels)
      sortedSSIs = new GeneralSSIList(biggestSSIsFirst(currentSSIs));
    else
      fail("Unknown sort mode");
    currentSSIs = sortedSSIs;
  }
  
  stage "Cut SSI List by detail level" {
    maxLines = !detailLevel.hasTarget() ? Int.MAX_VALUE
      : iround(detailDivisor()*detailLevel.target());
    currentSSIs = cutSSIs = new GeneralSSIList(takeFirstNSSILines(maxLines, currentSSIs));
    detailLevel.set(l(cutSSIs)/detailDivisor());
  }
  
  stage "Cut Vector-Optimized SSIs by file size" {
    maxInts = !kilobytes.hasTarget() ? Int.MAX_VALUE
      : iround(kilobytes.target()*512); // assuming 16 bit ints
    cutter = new CutListToBudget<AbstractSSI>(ssi -> (double) ssi.sizeInInts(), maxInts, (L) currentSSIs);
    
    if (allowPartialSSIs)
      cutter.allowPartial((ssi, budget) -> ssi.reduceToInts(iround(budget)));
      
    currentSSIs = cutVectorizedSSIs = new GeneralSSIList(cutter!);
    kilobytes.set(totalSizeInInts(cutVectorizedSSIs)/512.0);
  }
  
  L<IImageRegion<Hi15Image>> regions() {
    stepUntilStage(regionsStage);
    ret regions;
  }
  
  L<IImageRegion<Hi15Image>> regionsBySize() {
    stepUntilStage(biggestRegionsStage);
    ret regions;
  }
  
  L<IBinaryImage> regionsAsIBinaryImages() {
    ret map regionToIBinaryImage(regions());
  }
  
  BlurAndPosterizeSettings bnpSettings() {
    ret new BlurAndPosterizeSettings()
      .blur(blur)
      .colors(colors())
      .colorDrift(new RGB(drift()))
      .antiDrift(new RGB(antiDrift));
  }
  
  void importSettings(BlurAndPosterizeSettings bnp) {
    blur(bnp.blur);
    colors(bnp.colors);
    drift(bnp.colorDrift.brightness());
    antiDrift(bnp.antiDrift.brightness());
  }
  
  FastRegions_Hi15Image preparedRegionMaker() {
    stepUntilStage(prepareRegionsStage);
    ret regionMaker;
  }
  
  FastRegions_Hi15Image regionMaker() {
    stepUntilStage(regionsStage);
    ret regionMaker;
  }
  
  toString {
    ret commaCombine(
      shortClassName(this),
      imageSize(inputImage),
      "completed stages: " + or2(joinWithComma(completedStages()), "-")
    );
  }
  
  Hi15Image posterizedImage() {
    stepUntilStage(posterizeStage);
    ret posterizedImage;
  }
}