// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package com.google.typography.font.compression;

import com.google.typography.font.sfntly.Font;
import com.google.typography.font.sfntly.Tag;
import com.google.typography.font.sfntly.data.ReadableFontData;
import com.google.typography.font.sfntly.table.core.FontHeaderTable;
import com.google.typography.font.sfntly.table.truetype.CompositeGlyph;
import com.google.typography.font.sfntly.table.truetype.Glyph;
import com.google.typography.font.sfntly.table.truetype.GlyphTable;
import com.google.typography.font.sfntly.table.truetype.LocaTable;
import com.google.typography.font.sfntly.table.truetype.SimpleGlyph;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * Implementation of compression of CTF glyph data, as per sections 5.6-5.10 and 6 of the spec.
 * This is a hacked-up version with a number of options, for experimenting.
 *
 * @author Raph Levien
 */
public class GlyfEncoder {

  private final ByteArrayOutputStream nContourStream;
  private final ByteArrayOutputStream nPointsStream;
  private final ByteArrayOutputStream flagBytesStream;
  private final ByteArrayOutputStream compositeStream;
  private final ByteArrayOutputStream bboxStream;
  private final ByteArrayOutputStream glyfStream;
  private final ByteArrayOutputStream pushStream;
  private final ByteArrayOutputStream codeStream;
  private final boolean sbbox;
  private final boolean cbbox;
  private final boolean code;
  private final boolean triplet;
  private final boolean doPush;
  private final boolean doHop;
  private final boolean push2byte;
  private final boolean reslice;

  private int nGlyphs;
  private byte[] bboxBitmap;
  private FontHeaderTable.IndexToLocFormat indexFmt;

  public GlyfEncoder(String options) {
    glyfStream = new ByteArrayOutputStream();
    pushStream = new ByteArrayOutputStream();
    codeStream = new ByteArrayOutputStream();
    nContourStream = new ByteArrayOutputStream();
    nPointsStream = new ByteArrayOutputStream();
    flagBytesStream = new ByteArrayOutputStream();
    compositeStream = new ByteArrayOutputStream();
    bboxStream = new ByteArrayOutputStream();
    boolean sbbox = false;
    boolean cbbox = false;
    boolean code = false;
    boolean triplet = false;
    boolean doPush = false;
    boolean reslice = false;
    boolean doHop = false;
    boolean push2byte = false;
    for (String option : options.split(",")) {
      if (option.equals("sbbox")) {
        sbbox = true;
      } else if (option.equals("cbbox")) {
        cbbox = true;
      } else if (option.equals("code")) {
        code = true;
      } else if (option.equals("triplet")) {
        triplet = true;
      } else if (option.equals("push")) {
        doPush = true;
      } else if (option.equals("hop")) {
        doHop = true;
      } else if (option.equals("push2byte")) {
        push2byte = true;
      } else if (option.equals("reslice")) {
        reslice = true;
      }
    }
    this.sbbox = sbbox;
    this.cbbox = cbbox;
    this.code = code;
    this.triplet = triplet;
    this.doPush = doPush;
    this.doHop = doHop;
    this.push2byte = push2byte;
    this.reslice = reslice;
  }

  public void encode(Font sourceFont) {
    FontHeaderTable head = sourceFont.getTable(Tag.head);
    indexFmt = head.indexToLocFormat();
    LocaTable loca = sourceFont.getTable(Tag.loca);
    nGlyphs = loca.numGlyphs();
    GlyphTable glyf = sourceFont.getTable(Tag.glyf);
    bboxBitmap = new byte[((nGlyphs + 31) >> 5) << 2];

    for (int glyphId = 0; glyphId < nGlyphs; glyphId++) {
      int sourceOffset = loca.glyphOffset(glyphId);
      int length = loca.glyphLength(glyphId);
      Glyph glyph = glyf.glyph(sourceOffset, length);
      writeGlyph(glyphId, glyph);
    }
  }

  private void writeGlyph(int glyphId, Glyph glyph) {
    try {
      if (glyph == null || glyph.dataLength() == 0) {
        writeNContours(0);
      } else if (glyph instanceof SimpleGlyph) {
        writeSimpleGlyph(glyphId, (SimpleGlyph)glyph);
      } else if (glyph instanceof CompositeGlyph) {
        writeCompositeGlyph(glyphId, (CompositeGlyph)glyph);
      }
    } catch (IOException e) {
      throw new RuntimeException("unexpected IOException writing glyph data", e);
    }
  }

  private void writeInstructions(Glyph glyph) throws IOException{
    if (doPush) {
      splitPush(glyph);
    } else {
      int pushCount = 0;
      int codeSize = glyph.instructionSize();
      if (!reslice) {
        write255UShort(glyfStream, pushCount);
      }
      write255UShort(glyfStream, codeSize);
      if (codeSize > 0) {
        if (code) {
          glyph.instructions().copyTo(codeStream);
        } else {
          glyph.instructions().copyTo(glyfStream);
        }
      }
    }
  }

  private void writeSimpleGlyph(int glyphId, SimpleGlyph glyph) throws IOException {
    int numContours = glyph.numberOfContours();
    writeNContours(numContours);
    if (sbbox) {
      writeBbox(glyphId, glyph);
    }
    // TODO: check that bbox matches, write bbox if not
    for (int i = 0; i < numContours; i++) {
      if (reslice) {
        write255UShort(nPointsStream, glyph.numberOfPoints(i));
      } else {
        write255UShort(glyfStream, glyph.numberOfPoints(i) - (i == 0 ? 1 : 0));
      }
    }
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    int lastX = 0;
    int lastY = 0;
    for (int i = 0; i < numContours; i++) {
      int numPoints = glyph.numberOfPoints(i);
      for (int j = 0; j < numPoints; j++) {
        int x = glyph.xCoordinate(i, j);
        int y = glyph.yCoordinate(i, j);
        int dx = x - lastX;
        int dy = y - lastY;
        if (triplet) {
          writeTriplet(os, glyph.onCurve(i, j), dx, dy);
        } else {
          writeVShort(os, dx * 2 + (glyph.onCurve(i, j) ? 1 : 0));
          writeVShort(os, dy);
        }
        lastX = x;
        lastY = y;
      }
    }
    os.writeTo(glyfStream);
    if (numContours > 0) {
      writeInstructions(glyph);
    }
  }

  private void writeCompositeGlyph(int glyphId, CompositeGlyph glyph) throws IOException {
    boolean haveInstructions = false;
    writeNContours(-1);
    if (cbbox) {
      writeBbox(glyphId, glyph);
    }
    ByteArrayOutputStream outStream = reslice ? compositeStream : glyfStream;
    for (int i = 0; i < glyph.numGlyphs(); i++) {
      int flags = glyph.flags(i);
      writeUShort(outStream, flags);
      haveInstructions = (flags & CompositeGlyph.FLAG_WE_HAVE_INSTRUCTIONS) != 0;
      writeUShort(outStream, glyph.glyphIndex(i));
      if ((flags & CompositeGlyph.FLAG_ARG_1_AND_2_ARE_WORDS) == 0) {
        outStream.write(glyph.argument1(i));
        outStream.write(glyph.argument2(i));
      } else {
        writeUShort(outStream, glyph.argument1(i));
        writeUShort(outStream, glyph.argument2(i));
      }
      if (glyph.transformationSize(i) != 0) {
        try {
          outStream.write(glyph.transformation(i));
        } catch (IOException e) {
        }
      }
    }
    if (haveInstructions) {
      writeInstructions(glyph);
    }
  }

  private void writeNContours(int nContours) {
    if (reslice) {
      writeUShort(nContourStream, nContours);
    } else {
      writeUShort(nContours);
    }
  }

  private void writeBbox(int glyphId, Glyph glyph) {
    if (reslice) {
      bboxBitmap[glyphId >> 3] |= 0x80 >> (glyphId & 7);
    }
    ByteArrayOutputStream outStream = reslice ? bboxStream : glyfStream;
    writeUShort(outStream, glyph.xMin());
    writeUShort(outStream, glyph.yMin());
    writeUShort(outStream, glyph.xMax());
    writeUShort(outStream, glyph.yMax());
  }

  private void writeUShort(ByteArrayOutputStream os, int value) {
    os.write(value >> 8);
    os.write(value & 255);
  }

  private void writeUShort(int value) {
    writeUShort(glyfStream, value);
  }

  private void writeLong(OutputStream os, int value) throws IOException {
    os.write((value >> 24) & 255);
    os.write((value >> 16) & 255);
    os.write((value >> 8) & 255);
    os.write(value & 255);
  }

  // As per 6.1.1 of spec
  // visible for testing
  static void write255UShort(ByteArrayOutputStream os, int value) {
    if (value < 0) {
      throw new IllegalArgumentException();
    }
    if (value < 253) {
      os.write((byte)value);
    } else if (value < 506) {
      os.write(255);
      os.write((byte)(value - 253));
    } else if (value < 762) {
      os.write(254);
      os.write((byte)(value - 506));
    } else {
      os.write(253);
      os.write((byte)(value >> 8));
      os.write((byte)(value & 0xff));
    }
  }

  // As per 6.1.1 of spec
  // visible for testing
  static void write255Short(OutputStream os, int value) throws IOException {
    int absValue = Math.abs(value);
    if (value < 0) {
      // spec is unclear about whether words should be signed. This code is conservative, but we
      // can test once the implementation is working.
      os.write(250);
    }
    if (absValue < 250) {
      os.write((byte)absValue);
    } else if (absValue < 500) {
      os.write(255);
      os.write((byte)(absValue - 250));
    } else if (absValue < 756) {
      os.write(254);
      os.write((byte)(absValue - 500));
    } else {
      os.write(253);
      os.write((byte)(absValue >> 8));
      os.write((byte)(absValue & 0xff));
    }
  }

  // A simple signed varint encoding
  static void writeVShort(ByteArrayOutputStream os, int value) {
    if (value >= 0x2000 || value < -0x2000) {
      os.write((byte)(0x80 | ((value >> 14) & 0x7f)));
    }
    if (value >= 0x40 || value < -0x40) {
      os.write((byte)(0x80 | ((value >> 7) & 0x7f)));
    }
    os.write((byte)(value & 0x7f));
  }

  // As in section 5.11 of the spec
  // visible for testing
  void writeTriplet(OutputStream os, boolean onCurve, int x, int y) throws IOException {
    int absX = Math.abs(x);
    int absY = Math.abs(y);
    int onCurveBit = onCurve ? 0 : 128;
    int xSignBit = (x < 0) ? 0 : 1;
    int ySignBit = (y < 0) ? 0 : 1;
    int xySignBits = xSignBit + 2 * ySignBit;
    ByteArrayOutputStream flagStream = reslice ? flagBytesStream : glyfStream;

    if (x == 0 && absY < 1280) {
      flagStream.write(onCurveBit + ((absY & 0xf00) >> 7) + ySignBit);
      os.write(absY & 0xff);
    } else if (y == 0 && absX < 1280) {
      flagStream.write(onCurveBit + 10 + ((absX & 0xf00) >> 7) + xSignBit);
      os.write(absX & 0xff);
    } else if (absX < 65 && absY < 65) {
      flagStream.write(onCurveBit + 20 + ((absX - 1) & 0x30) + (((absY - 1) & 0x30) >> 2) +
          xySignBits);
      os.write((((absX - 1) & 0xf) << 4) | ((absY - 1) & 0xf));
    } else if (absX < 769 && absY < 769) {
      flagStream.write(onCurveBit + 84 + 12 * (((absX - 1) & 0x300) >> 8) +
          (((absY - 1) & 0x300) >> 6) + xySignBits);
      os.write((absX - 1) & 0xff);
      os.write((absY - 1) & 0xff);
    } else if (absX < 4096 && absY < 4096) {
      flagStream.write(onCurveBit + 120 + xySignBits);
      os.write(absX >> 4);
      os.write(((absX & 0xf) << 4) | (absY >> 8));
      os.write(absY & 0xff);
    } else {
      flagStream.write(onCurveBit + 124 + xySignBits);
      os.write(absX >> 8);
      os.write(absX & 0xff);
      os.write(absY >> 8);
      os.write(absY & 0xff);
    }
  }

  /**
   * Split the instructions into a push sequence and the remainder of the instructions.
   * Writes both streams, and the counts to the glyfStream.
   *
   * @param glyph
   */
  private void splitPush(Glyph glyph) throws IOException {
    int instrSize = glyph.instructionSize();
    ReadableFontData data = glyph.instructions();
    int i = 0;
    List<Integer> result = new ArrayList<Integer>();
    // All push sequences are at least two bytes, make sure there's enough room
    while (i + 1 < instrSize) {
      int ix = i;
      int instr = data.readUByte(ix++);
      int n = 0;
      int size = 0;
      if (instr == 0x40 || instr == 0x41) {
        // NPUSHB, NPUSHW
        n = data.readUByte(ix++);
        size = (instr & 1) + 1;
      } else if (instr >= 0xB0 && instr < 0xC0) {
        // PUSHB, PUSHW
        n = 1 + (instr & 7);
        size = ((instr & 8) >> 3) + 1;
      } else {
        break;
      }
      if (i + size * n > instrSize) {
        // This is a broken font, and a potential buffer overflow, but in the interest
        // of preserving the original, we just put the broken instruction sequence in
        // the stream.
        break;
      }
      for (int j = 0; j < n; j++) {
        if (size == 1) {
          result.add(data.readUByte(ix));
        } else {
          result.add(data.readShort(ix));
        }
        ix += size;
      }
      i = ix;
    }
    int pushCount = result.size();
    int codeSize = instrSize - i;
    write255UShort(glyfStream, pushCount);
    write255UShort(glyfStream, codeSize);
    encodePushSequence(pushStream, result);
    if (codeSize > 0) {
      data.slice(i).copyTo(codeStream);
    }
  }

  // As per section 6.2.2 of the spec
  private void encodePushSequence(ByteArrayOutputStream os, List<Integer> data) throws IOException {
    int n = data.size();
    int hopSkip = 0;
    for (int i = 0; i < n; i++) {
      if ((hopSkip & 1) == 0) {
        int val = data.get(i);
        if (doHop && hopSkip == 0 && i >= 2 &&
            i + 2 < n && val == data.get(i - 2) && val == data.get(i + 2)) {
          if (i + 4 < n && val == data.get(i + 4)) {
            // Hop4 code
            os.write(252);
            hopSkip = 0x14;
          } else {
            // Hop3 code
            os.write(251);
            hopSkip = 4;
          }
        } else {
          if (push2byte) {
            // Measure relative effectiveness of 255Short literal encoding vs 2-byte ushort.
            writeUShort(os, data.get(i));
          } else {
            write255Short(os, data.get(i));
          }
        }
      }
      hopSkip >>= 1;
    }
  }

  public byte[] getGlyfBytes() {
    if (reslice) {
      ByteArrayOutputStream newStream = new ByteArrayOutputStream();
      try {
        // Pack all the glyf streams in a sensible way
        writeLong(newStream, 0);  // version
        writeUShort(newStream, nGlyphs);
        writeUShort(newStream, indexFmt.value());
        writeLong(newStream, nContourStream.size());
        writeLong(newStream, nPointsStream.size());
        writeLong(newStream, flagBytesStream.size());
        writeLong(newStream, glyfStream.size());
        writeLong(newStream, compositeStream.size());
        writeLong(newStream, bboxBitmap.length + bboxStream.size());
        writeLong(newStream, codeStream.size());
//        System.out.printf("stream sizes = %d %d %d %d %d %d %d\n",
//            nContourStream.size(), nPointsStream.size(), flagBytesStream.size(), glyfStream.size(),
//            compositeStream.size(), bboxStream.size(), codeStream.size());
        nContourStream.writeTo(newStream);
        nPointsStream.writeTo(newStream);
        flagBytesStream.writeTo(newStream);
        glyfStream.writeTo(newStream);
        compositeStream.writeTo(newStream);
        newStream.write(bboxBitmap);
        bboxStream.writeTo(newStream);
        codeStream.writeTo(newStream);
      } catch (IOException e) {
        throw new RuntimeException("Can't happen, world must have come to end", e);
      }
      return newStream.toByteArray();
    } else {
      return glyfStream.toByteArray();
    }
  }

  public byte[] getPushBytes() {
    return pushStream.toByteArray();
  }

  public byte[] getCodeBytes() {
    return codeStream.toByteArray();
  }

  public byte[] getLocaBytes() {
    return new byte[]{ };
  }
}