// SSI - Simple Scanline Image

// A partial image consisting of exactly one horizontal line per row.

// All pixels are of the same color.

// The important values are y1 and data

persistable sclass SSI extends AbstractSSI is ByteIO, StringIO {

  replace X with short.

  replace Y with short.

  replace toX with toShort_enforce.

  replace toY with toShort_enforce.

  replace newXArray with newShortArrayOrNull.

  // core value (mandatory): first row occupied

  settable Y y1;

  // core value (mandatory): x coordinates per row

  // x_left is inclusive, x_right is exclusive

  // all x coordinates are absolute in image

  //

  // Order in array:

  //   x_left at y1, x_right at y1,

  //   x_left at y1+1, x_right at y1+1, ,,,

  settable X[] data;

  *(int y1, int y2) {

    init(y1, y2);

  }

  void init(int y1, int y2) {

    this.y1 = toY(y1);

    data = newXArray((y2-y1)*2);

  }

  // all coordinates passed in are absolute

  void set(int y, int xLeft, int xRight) {

    data[(y-y1)*2] = toX(xLeft);

    data[(y-y1)*2+1] = toX(xRight);

  }

  // all coordinates passed in and out are absolute

  int getLeft (int y) { ret data[(y-y1)*2]; }

  int getRight(int y) { ret data[(y-y1)*2+1]; }

  // bounds can be calculated quickly from core values & are then cached

  public simplyCached Rect bounds() {

    int x1 = Int.MAX_VALUE, x2 = 0;

    for (int i = 0; i < l(data); i += 2) {

      x1 = min(x1, data[i]);

      x2 = max(x2, data[i+1]);

    }

    ret rectFromPoints(x1, y1, x2, y2());

  }

  // same with number of pixels

  int numberOfPixels_cache = -1;

  public int numberOfPixels() {

    if (numberOfPixels_cache < 0) {

      int n = 0;

      for (int i = 0; i < l(data); i += 2)

        n += max(0, data[i+1]-data[i]);

      numberOfPixels_cache = n;

    }

    ret numberOfPixels_cache;

  }

  public int getHeight() { ret l(data)/2; }

  int y2() { ret y1+height(); }

  public bool contains(Pt p) { ret contains(p.x, p.y); }

  public bool contains(int x, int y) {

    if (y < y1) false;

    int i = (y-y1)*2;

    if (i >= l(data)) false;

    ret x >= data[i] && x < data[i+1];

  }

  selfType color(Color color) { super.color(color); this; }

  public selfType hi15color(short hi15color) { super.hi15color(hi15color); this; }

  public void drawOn(Graphics2D g) {

    g.setColor(color());

    int h = height();

    for y to h: {

      int x1 = data[y*2], x2 = data[y*2+1];

      if (x1 < x2)

        g.drawLine(x1, y1+y, x2-1, y1+y);

    }

  }

  // doesn't set a color

  // TODO

  public void drawOutline(Graphics2D g) {

    int h = height();

    IntRange last = intRange(0, 0);

    for y to h: {

      IntRange r = intRange(data[y*2], data[y*2+1]);

      // anything to draw in this line?

      if (nempty(r)) {

        if (empty(last))

          // draw full line if just starting

          g.drawLine(r.start, y1+y, r.end-1, y1+y);

        else {

          // We make a line from the left boundary that if possible goes only to last.start but is at least 1 pixel wide

          int xleft = max(r.start, last.start-1);

          // Same from the right boundary

          int xright = min(r.end-1, last.end);

          g.drawLine(r.start, y1+y, xleft, y1+y);

          g.drawLine(xright, y1+y, r.end-1, y1+y);

        }

      }

      last = r;

    }

  }

  SSI topPart(int nLines) {

    if (nLines <= 0) null;

    SSI ssi = new SSI(y1, toShort_enforce(y1+nLines)).hi15color(hi15color);

    arrayCopy(data, ssi.data, 0, l(ssi.data));

    ret ssi;

  }

  // an SSI is coherent if all scanlines are non-empty

  // and the SSI is one region

  bool coherent(bool withDiagonals default false) {

    int h = height();

    for y to h: {

      int i = y*2;

      int x1 = data[i], x2 = data[i+1];

      if (x1 >= x2) false;

      if (y > 0) {

        int lastx1 = data[i-2], lastx2 = data[i-1];

        if (withDiagonals) { lastx1--; lastx2++; }

        if (!intRangesOverlap(x1, x2, lastx1, lastx2))

          false;

      }

    }

    true;

  }

  public void readWrite(ByteHead head) {

    head.exchangeShort(-> hi15color, color -> hi15color = color);

    head.exchangeShort(-> y1, y1 -> this.y1 = y1);

    head.exchangeShort(-> toShort_enforce(y2()), y2 -> init(y1, y2));

    for i over data: {

      reMutable i;

      head.exchangeShort(-> data[i], x -> data[i] = x);

    }

  }

  SSI toSSI() { this; }

  public long sizeInInts() {

    // "s", color, y1, height, data

    ret 4+height()*2;

  }

  SSI reduceToInts(int ints) {

    ret topPart((ints-4)/2);

  }

  public void readWrite(StringHead head) {

    head.exchangeLine(l0 toLine, l1 fromLine);

  }

  S toLine() {

    ret spaceCombine("s", colorToString(), y1, height(), toList(data));

  }

  void fromLine(S line) {

    Iterator<S> it = splitAtSpaceIterator(line);

    assertEquals("s", nextFromIterator(it));

    int y1 = parseInt(nextFromIterator(it));

    int h = parseInt(nextFromIterator(it));

    init(y1, y1+h);

    for i over data:

      data[i] = toX(parseInt(nextFromIterator(it)));

  }

}