import jdk.incubator.vector.*;

// TODO: image w/h not divisible by 8

final sclass BWIntegralImage_doubleVectorized implements MakesBufferedImage, IBWIntegralImage {
  // dual logarithm of block size & corresponding int vector species
  replace blockShift with 3.
  replace species with IntVector.SPECIES_256.
  replace blockSize with (1 << blockShift).
  
  int w, h; // actual image size
  int blockW, blockH; // width and height of block array
  Block[] blocks;
  ifdef BWIntegralImage_CountAccesses
    long accesses;
  endifdef
  
  sclass Block {
    int[] rowAndColSums = new[blockSize*2]; // length 16
    int sum;
    int[] data; // length 64 if calculated
  }
  
  *() {}
  *(File f) { this(loadImage2(f)); }
  
  *(MakesBufferedImage img) { this(toBufferedImage(img)); }
  
  *(BufferedImage image) ctex {
    alloc(image.getWidth(), image.getHeight());
    
    // Grab image
    // TODO: could use grayscale color model here (faster?)
    int[] data = new[w*h];
    PixelGrabber pixelGrabber = new PixelGrabber(image, 0, 0, w, h, data, 0, w);
    if (!pixelGrabber.grabPixels())
      fail("Could not grab pixels");
      
    // for brightness of pixels,
    // for now we cheat by just using one of the channels
    
    // calculate sums in each block
    
    int iBlock = 0;
    for by to blockH: {
      int iLine = (by << blockShift)*w;
      for bx to blockW: {
        Block block = blocks[iBlock++];
        int[] sums = block.rowAndColSums;
        
        IntVector vColSums = by == 0 ? IntVector.zero(species) : IntVector.fromArray(species, getBlock(bx, by-1).rowAndColSums, blockSize);
        int[] leftSums = bx == 0 ? null : getBlock(bx-1, by).rowAndColSums;
        
        for (int y = 0; y < blockSize; y++) {
          IntVector v = IntVector.fromArray(species, data, y << blockShift);
          int leftSum = leftSums != null ? leftSums[y] : 0;
          sums[y] = v.reduceLanes(VectorOperators.ADD)+leftSum;
          v = v.add(leftSum);
          vColSums = vColSums.add(v);
        }
        vColSums.intoArray(sums, blockSize);
        block.sum = vColSums.reduceLanes(VectorOperators.ADD);
      }
    }
  }
  
  int blockSum(int bx, int by) {
    ret bx < 0 || by < 0 ? 0 : getBlock(bx, by).sum;
  }
  
  Block getBlock(int bx, int by) { ret blocks[by*blockW+bx]; }
  
  int[] getBlockData(int bx, int by) {
    Block block = getBlock(bx, by);
    if (block.data == null)
      calcData(bx, by, block);
    ret block.data;
  }
  
  void calcData(int bx, int by, Block block) {
    todo();
  }
  
  private void alloc(int w, int h) {
    if ((w % blockSize) != 0 || (h % blockSize) != 0)
      fail("Need image dimensions divisible by " + blockSize + ": " + w + "*" + h);

    this.w = w;
    this.h = h;
    blockW = ratioRoundUp(w, blockSize);
    blockH = ratioRoundUp(h, blockSize);
    //int dataLength = blockSize*blockSize;
    blocks = repF_array Block(blockW*blockH, () -> new Block);
  }
  
  // get sum value at x, y
  // pixels outside of image are considered black
  public int getIIValue(int x, int y) {
    ifdef BWIntegralImage_CountAccesses
      ++accesses;
    endifdef
    if (x < 0 || y < 0 || x >= w || y >= h) ret 0;
    int idx = ((x & (blockSize-1)) << blockSize) | (y & (blockSize-1));
    ret idx == 0 ? getBlock(x >> blockShift, y >> blockShift).sum
      : getBlockData(x >> blockShift, y >> blockShift)[idx];
  }
  
  public double getPixelAverage(int x1, int y1, int x2, int y2) {
    int area = (x2-x1)*(y2-y1);
    ret doubleRatio(bwIntegralImage_sumRect(this, x1, y1, x2, y2), area);
  }
  
  int getPixel(int x, int y) {
    ret bwIntegralImage_sumRect(this, x, y, x+1, y+1);
  }
  
  int getPixel(Pt p) { ret getPixel(p.x, p.y); }
  
  public int getWidth() { ret w; }
  public int getHeight() { ret h; }
  
  // unoptimized
  public BufferedImage getBufferedImage() {
    ret scaleDownUsingIntegralImageBW(this, w, h).getBufferedImage();
  }
}