#include <u.h>
#include <libc.h>
#include <draw.h>
#include <mouse.h>
#include <frame.h>

#define DELTA 25
#define TMPSIZE 256
static Frame frame;

static Point bxscan(Frame* f, Rune* sp, Rune* ep, Point* ppt) {
  int w, c, nb, delta, nl, nr, rw;
  Frbox* b;
  char *s, tmp[TMPSIZE + 3]; /* +3 for rune overflow */
  uchar* p;

  frame.r = f->r;
  frame.b = f->b;
  frame.font = f->font;
  frame.maxtab = f->maxtab;
  frame.nbox = 0;
  frame.nchars = 0;
  memmove(frame.cols, f->cols, sizeof frame.cols);
  delta = DELTA;
  nl = 0;
  for (nb = 0; sp < ep && nl <= f->maxlines; nb++, frame.nbox++) {
    if (nb == frame.nalloc) {
      _frgrowbox(&frame, delta);
      if (delta < 10000)
        delta *= 2;
    }
    b = &frame.box[nb];
    c = *sp;
    if (c == '\t' || c == '\n') {
      b->bc = c;
      b->wid = 5000;
      b->minwid = (c == '\n') ? 0 : stringwidth(frame.font, " ");
      b->nrune = -1;
      if (c == '\n')
        nl++;
      frame.nchars++;
      sp++;
    } else {
      s = tmp;
      nr = 0;
      w = 0;
      while (sp < ep) {
        c = *sp;
        if (c == '\t' || c == '\n')
          break;
        rw = runetochar(s, sp);
        if (s + rw >= tmp + TMPSIZE)
          break;
        w += runestringnwidth(frame.font, sp, 1);
        sp++;
        s += rw;
        nr++;
      }
      *s++ = 0;
      p = _frallocstr(f, s - tmp);
      b = &frame.box[nb];
      b->ptr = p;
      memmove(p, tmp, s - tmp);
      b->wid = w;
      b->nrune = nr;
      frame.nchars += nr;
    }
  }
  _frcklinewrap0(f, ppt, &frame.box[0]);
  return _frdraw(&frame, *ppt);
}

static void chopframe(Frame* f, Point pt, ulong p, int bn) {
  Frbox* b;

  for (b = &f->box[bn];; b++) {
    if (b >= &f->box[f->nbox])
      drawerror(f->display, "endofframe");
    _frcklinewrap(f, &pt, b);
    if (pt.y >= f->r.max.y)
      break;
    p += NRUNE(b);
    _fradvance(f, &pt, b);
  }
  f->nchars = p;
  f->nlines = f->maxlines;
  if (b < &f->box[f->nbox]) /* BUG */
    _frdelbox(f, (int)(b - f->box), f->nbox - 1);
}

void frinsert(Frame* f, Rune* sp, Rune* ep, ulong p0) {
  Point pt0, pt1, opt0, ppt0, ppt1, pt;
  Frbox* b;
  int n, n0, nn0, y;
  ulong cn0;
  Image *col, *tcol;
  Rectangle r;
  static struct { Point pt0, pt1; } * pts;
  static int nalloc = 0;
  int npts;

  if (p0 > f->nchars || sp == ep || f->b == nil)
    return;
  n0 = _frfindbox(f, 0, 0, p0);
  cn0 = p0;
  nn0 = n0;
  pt0 = _frptofcharnb(f, p0, n0);
  ppt0 = pt0;
  opt0 = pt0;
  pt1 = bxscan(f, sp, ep, &ppt0);
  ppt1 = pt1;
  if (n0 < f->nbox) {
    _frcklinewrap(f, &pt0, b = &f->box[n0]); /* for frdrawsel() */
    _frcklinewrap0(f, &ppt1, b);
  }
  f->modified = 1;
  /*
   * ppt0 and ppt1 are start and end of insertion as they will appear when
   * insertion is complete. pt0 is current location of insertion position
   * (p0); pt1 is terminal point (without line wrap) of insertion.
   */
  if (f->p0 == f->p1)
    frtick(f, frptofchar(f, f->p0), 0);

  /*
   * Find point where old and new x's line up
   * Invariants:
   *	pt0 is where the next box (b, n0) is now
   *	pt1 is where it will be after the insertion
   * If pt1 goes off the rectangle, we can toss everything from there on
   */
  for (b = &f->box[n0], npts = 0;
       pt1.x != pt0.x && pt1.y != f->r.max.y && n0 < f->nbox;
       b++, n0++, npts++) {
    _frcklinewrap(f, &pt0, b);
    _frcklinewrap0(f, &pt1, b);
    if (b->nrune > 0) {
      n = _frcanfit(f, pt1, b);
      if (n == 0)
        drawerror(f->display, "_frcanfit==0");
      if (n != b->nrune) {
        _frsplitbox(f, n0, n);
        b = &f->box[n0];
      }
    }
    if (npts == nalloc) {
      pts = realloc(pts, (npts + DELTA) * sizeof(pts[0]));
      nalloc += DELTA;
      b = &f->box[n0];
    }
    pts[npts].pt0 = pt0;
    pts[npts].pt1 = pt1;
    /* has a text box overflowed off the frame? */
    if (pt1.y == f->r.max.y)
      break;
    _fradvance(f, &pt0, b);
    pt1.x += _frnewwid(f, pt1, b);
    cn0 += NRUNE(b);
  }
  if (pt1.y > f->r.max.y)
    drawerror(f->display, "frinsert pt1 too far");
  if (pt1.y == f->r.max.y && n0 < f->nbox) {
    f->nchars -= _frstrlen(f, n0);
    _frdelbox(f, n0, f->nbox - 1);
  }
  if (n0 == f->nbox)
    f->nlines = (pt1.y - f->r.min.y) / f->font->height + (pt1.x > f->r.min.x);
  else if (pt1.y != pt0.y) {
    int q0, q1;

    y = f->r.max.y;
    q0 = pt0.y + f->font->height;
    q1 = pt1.y + f->font->height;
    f->nlines += (q1 - q0) / f->font->height;
    if (f->nlines > f->maxlines)
      chopframe(f, ppt1, p0, nn0);
    if (pt1.y < y) {
      r = f->r;
      r.min.y = q1;
      r.max.y = y;
      if (q1 < y)
        draw(f->b, r, f->b, nil, Pt(f->r.min.x, q0));
      r.min = pt1;
      r.max.x = pt1.x + (f->r.max.x - pt0.x);
      r.max.y = q1;
      draw(f->b, r, f->b, nil, pt0);
    }
  }
  /*
   * Move the old stuff down to make room.  The loop will move the stuff
   * between the insertion and the point where the x's lined up.
   * The draw()s above moved everything down after the point they lined up.
   */
  for ((y = pt1.y == f->r.max.y ? pt1.y : 0), b = &f->box[n0 - 1]; --npts >= 0;
       --b) {
    pt = pts[npts].pt1;
    if (b->nrune > 0) {
      r.min = pt;
      r.max = r.min;
      r.max.x += b->wid;
      r.max.y += f->font->height;
      draw(f->b, r, f->b, nil, pts[npts].pt0);
      /* clear bit hanging off right */
      if (npts == 0 && pt.y > pt0.y) {
        /*
         * first new char is bigger than first char we're
         * displacing, causing line wrap. ugly special case.
         */
        r.min = opt0;
        r.max = opt0;
        r.max.x = f->r.max.x;
        r.max.y += f->font->height;
        if (f->p0 <= cn0 && cn0 < f->p1) /* b+1 is inside selection */
          col = f->cols[HIGH];
        else
          col = f->cols[BACK];
        draw(f->b, r, col, nil, r.min);
      } else if (pt.y < y) {
        r.min = pt;
        r.max = pt;
        r.min.x += b->wid;
        r.max.x = f->r.max.x;
        r.max.y += f->font->height;
        if (f->p0 <= cn0 && cn0 < f->p1) /* b+1 is inside selection */
          col = f->cols[HIGH];
        else
          col = f->cols[BACK];
        draw(f->b, r, col, nil, r.min);
      }
      y = pt.y;
      cn0 -= b->nrune;
    } else {
      r.min = pt;
      r.max = pt;
      r.max.x += b->wid;
      r.max.y += f->font->height;
      if (r.max.x >= f->r.max.x)
        r.max.x = f->r.max.x;
      cn0--;
      if (f->p0 <= cn0 && cn0 < f->p1) { /* b is inside selection */
        col = f->cols[HIGH];
        tcol = f->cols[HTEXT];
      } else {
        col = f->cols[BACK];
        tcol = f->cols[TEXT];
      }
      draw(f->b, r, col, nil, r.min);
      y = 0;
      if (pt.x == f->r.min.x)
        y = pt.y;
    }
  }
  /* insertion can extend the selection, so the condition here is different */
  if (f->p0 < p0 && p0 <= f->p1) {
    col = f->cols[HIGH];
    tcol = f->cols[HTEXT];
  } else {
    col = f->cols[BACK];
    tcol = f->cols[TEXT];
  }
  frselectpaint(f, ppt0, ppt1, col);
  _frdrawtext(&frame, ppt0, tcol, col);
  _fraddbox(f, nn0, frame.nbox);
  for (n = 0; n < frame.nbox; n++)
    f->box[nn0 + n] = frame.box[n];
  if (
    nn0 > 0 && f->box[nn0 - 1].nrune >= 0 &&
    ppt0.x - f->box[nn0 - 1].wid >= f->r.min.x) {
    --nn0;
    ppt0.x -= f->box[nn0].wid;
  }
  n0 += frame.nbox;
  _frclean(f, ppt0, nn0, n0 < f->nbox - 1 ? n0 + 1 : n0);
  f->nchars += frame.nchars;
  if (f->p0 >= p0)
    f->p0 += frame.nchars;
  if (f->p0 > f->nchars)
    f->p0 = f->nchars;
  if (f->p1 >= p0)
    f->p1 += frame.nchars;
  if (f->p1 > f->nchars)
    f->p1 = f->nchars;
  if (f->p0 == f->p1)
    frtick(f, frptofchar(f, f->p0), 1);
}