package juloo.keyboard2;

import android.content.res.Resources;
import android.content.res.XmlResourceParser;
import android.util.Xml;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import org.xmlpull.v1.XmlPullParser;

class KeyboardData
{
  public final List<Row> rows;
  /** Total width of the keyboard. */
  public final float keysWidth;
  /** Total height of the keyboard. */
  public final float keysHeight;

  public KeyboardData mapKeys(MapKey f)
  {
    ArrayList<Row> rows_ = new ArrayList<Row>();
    for (Row r : rows)
      rows_.add(r.mapKeys(f));
    return new KeyboardData(rows_, keysWidth);
  }

  /** Add keys from the given iterator into the keyboard. Extra keys are added
   * on the empty key4 corner of the second row, from right to left. If there's
   * not enough room, key3 of the second row is tried then key2 and key1 of the
   * third row. */
  public KeyboardData addExtraKeys(Iterator<KeyValue> k)
  {
    ArrayList<Row> rows = new ArrayList<Row>(this.rows);
    addExtraKeys_to_row(rows, k, 1, 4);
    addExtraKeys_to_row(rows, k, 1, 3);
    addExtraKeys_to_row(rows, k, 2, 2);
    addExtraKeys_to_row(rows, k, 2, 1);
    if (k.hasNext())
    {
      for (int r = 0; r < rows.size(); r++)
        for (int c = 1; c <= 4; c++)
          addExtraKeys_to_row(rows, k, r, c);
    }
    return new KeyboardData(rows, keysWidth);
  }

  public KeyboardData addNumPad()
  {
    ArrayList<Row> extendedRows = new ArrayList<Row>();
    Iterator<Row> iterNumPadRows = num_pad.rows.iterator();
    for (Row row : rows)
    {
      ArrayList<KeyboardData.Key> keys = new ArrayList<Key>(row.keys);
      if (iterNumPadRows.hasNext())
      {
        Row numPadRow = iterNumPadRows.next();
        List<Key> nps = numPadRow.keys;
        if (nps.size() > 0) {
          float firstNumPadShift = 0.5f + keysWidth - row.keysWidth;
          keys.add(nps.get(0).withShift(firstNumPadShift));
          for (int i = 1; i < nps.size(); i++)
            keys.add(nps.get(i));
        }
      }
      extendedRows.add(new Row(keys, row.height, row.shift));
    }
    return new KeyboardData(extendedRows, compute_max_width(extendedRows));
  }

  public KeyboardData addNumberRow()
  {
    ArrayList<Row> rows_ = new ArrayList<Row>(this.rows);
    rows_.add(0, number_row.updateWidth(keysWidth));
    return new KeyboardData(rows_, keysWidth);
  }

  public Key findKeyWithValue(KeyValue kv)
  {
    for (Row r : rows)
    {
      Key k = r.findKeyWithValue(kv);
      if (k != null)
        return k;
    }
    return null;
  }

  public void getKeys(Set<KeyValue> dst)
  {
    for (Row r : rows)
      r.getKeys(dst);
  }

  private static void addExtraKeys_to_row(ArrayList<Row> rows, final Iterator<KeyValue> extra_keys, int row_i, final int d)
  {
    if (!extra_keys.hasNext())
      return;
    rows.set(row_i, rows.get(row_i).mapKeys(new MapKey(){
      public Key apply(Key k) {
        if (k.getKeyValue(d) == null && extra_keys.hasNext())
          return k.withKeyValue(d, extra_keys.next());
        else
          return k;
      }
    }));
  }

  public static Row bottom_row;
  public static Row number_row;
  public static KeyboardData num_pad;
  public static KeyboardData pin_entry;
  private static Map<Integer, KeyboardData> _layoutCache = new HashMap<Integer, KeyboardData>();

  public static void init(Resources res)
  {
    try
    {
      bottom_row = parse_row(res.getXml(R.xml.bottom_row));
      number_row = parse_row(res.getXml(R.xml.number_row));
      num_pad = parse_keyboard(res.getXml(R.xml.numpad));
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  public static KeyboardData load_pin_entry(Resources res)
  {
    if (pin_entry == null)
      pin_entry = load(res, R.xml.pin);
    return pin_entry;
  }

  /** Load a layout from a resource ID. Returns [null] on error. */
  public static KeyboardData load(Resources res, int id)
  {
    KeyboardData l = _layoutCache.get(id);
    if (l == null)
    {
      try
      {
        XmlResourceParser parser = res.getXml(id);
        l = parse_keyboard(parser);
        parser.close();
        _layoutCache.put(id, l);
      }
      catch (Exception e)
      {
        e.printStackTrace();
      }
    }
    return l;
  }

  /** Load a layout from a string. Returns [null] on error. */
  public static KeyboardData load_string(String src)
  {
    try
    {
      XmlPullParser parser = Xml.newPullParser();
      parser.setInput(new StringReader(src));
      return parse_keyboard(parser);
    }
    catch (Exception e)
    {
      return null;
    }
  }

  private static KeyboardData parse_keyboard(XmlPullParser parser) throws Exception
  {
    if (!expect_tag(parser, "keyboard"))
      throw new Exception("Empty layout file");
    boolean add_bottom_row = attribute_bool(parser, "bottom_row", true);
    float specified_kw = attribute_float(parser, "width", 0f);
    ArrayList<Row> rows = new ArrayList<Row>();
    while (expect_tag(parser, "row"))
        rows.add(Row.parse(parser));
    float kw = (specified_kw != 0f) ? specified_kw : compute_max_width(rows);
    if (add_bottom_row)
      rows.add(bottom_row.updateWidth(kw));
    return new KeyboardData(rows, kw);
  }

  private static float compute_max_width(List<Row> rows)
  {
    float w = 0.f;
    for (Row r : rows)
      w = Math.max(w, r.keysWidth);
    return w;
  }

  private static Row parse_row(XmlPullParser parser) throws Exception
  {
    if (!expect_tag(parser, "row"))
      throw new Exception("Failed to parse row");
    return Row.parse(parser);
  }

  protected KeyboardData(List<Row> rows_, float kw)
  {
    float kh = 0.f;
    for (Row r : rows_)
      kh += r.height + r.shift;
    rows = rows_;
    keysWidth = kw;
    keysHeight = kh;
  }

  public static class Row
  {
    public final List<Key> keys;
    /** Height of the row, without 'shift'. */
    public final float height;
    /** Extra empty space on the top. */
    public final float shift;
    /** Total width of the row. */
    public final float keysWidth;

    protected Row(List<Key> keys_, float h, float s)
    {
      float kw = 0.f;
      for (Key k : keys_) kw += k.width + k.shift;
      keys = keys_;
      height = h;
      shift = s;
      keysWidth = kw;
    }

    public static Row parse(XmlPullParser parser) throws Exception
    {
      ArrayList<Key> keys = new ArrayList<Key>();
      int status;
      float h = attribute_float(parser, "height", 1f);
      float shift = attribute_float(parser, "shift", 0f);
      while (expect_tag(parser, "key"))
        keys.add(Key.parse(parser));
      return new Row(keys, h, shift);
    }

    public void getKeys(Set<KeyValue> dst)
    {
      for (Key k : keys)
        k.getKeys(dst);
    }

    public Row mapKeys(MapKey f)
    {
      ArrayList<Key> keys_ = new ArrayList<Key>();
      for (Key k : keys)
        keys_.add(f.apply(k));
      return new Row(keys_, height, shift);
    }

    /** Change the width of every keys so that the row is 's' units wide. */
    public Row updateWidth(float newWidth)
    {
      final float s = newWidth / keysWidth;
      return mapKeys(new MapKey(){
        public Key apply(Key k) { return k.scaleWidth(s); }
      });
    }

    public Key findKeyWithValue(KeyValue kv)
    {
      for (Key k : keys)
        if (k.hasValue(kv))
          return k;
      return null;
    }
  }

  public static class Key
  {
    /*
     ** 1   2
     **   0
     ** 3   4
     */
    public final Corner key0;
    public final Corner key1;
    public final Corner key2;
    public final Corner key3;
    public final Corner key4;

    /** Key width in relative unit. */
    public final float width;
    /** Extra empty space on the left of the key. */
    public final float shift;
    /** Put keys 1 to 4 on the edges instead of the corners. */
    public final boolean edgekeys;
    /** Keys 2 and 3 are repeated as the finger moves laterally on the key.
        Used for the left and right arrow keys on the space bar. */
    public final boolean slider;
    /** String printed on the keys. It has no other effect. */
    public final String indication;

    protected Key(Corner k0, Corner k1, Corner k2, Corner k3, Corner k4, float w, float s, boolean e, boolean sl, String i)
    {
      key0 = k0;
      key1 = k1;
      key2 = k2;
      key3 = k3;
      key4 = k4;
      width = w;
      shift = s;
      edgekeys = e;
      slider = sl;
      indication = i;
    }

    public static Key parse(XmlPullParser parser) throws Exception
    {
      Corner k0 = Corner.parse_of_attr(parser, "key0");
      Corner k1 = Corner.parse_of_attr(parser, "key1");
      Corner k2 = Corner.parse_of_attr(parser, "key2");
      Corner k3 = Corner.parse_of_attr(parser, "key3");
      Corner k4 = Corner.parse_of_attr(parser, "key4");
      float width = attribute_float(parser, "width", 1f);
      float shift = attribute_float(parser, "shift", 0.f);
      boolean edgekeys = attribute_bool(parser, "edgekeys", false);
      boolean slider = attribute_bool(parser, "slider", false);
      String indication = parser.getAttributeValue(null, "indication");
      while (parser.next() != XmlPullParser.END_TAG)
        continue ;
      return new Key(k0, k1, k2, k3, k4, width, shift, edgekeys, slider, indication);
    }

    /** New key with the width multiplied by 's'. */
    public Key scaleWidth(float s)
    {
      return new Key(key0, key1, key2, key3, key4, width * s, shift, edgekeys,
          slider, indication);
    }

    public void getKeys(Set<KeyValue> dst)
    {
      getCorner(dst, key0);
      getCorner(dst, key1);
      getCorner(dst, key2);
      getCorner(dst, key3);
      getCorner(dst, key4);
    }

    void getCorner(Set<KeyValue> dst, Corner k) { if (k != null) dst.add(k.kv); }

    public KeyValue getKeyValue(int i)
    {
      Corner c;
      switch (i)
      {
        case 0: c = key0; break;
        case 1: c = key1; break;
        case 2: c = key2; break;
        case 3: c = key3; break;
        case 4: c = key4; break;
        default: c = null; break;
      }
      return (c == null) ? null : c.kv;
    }

    public Key withKeyValue(int i, KeyValue kv)
    {
      Corner k0 = key0, k1 = key1, k2 = key2, k3 = key3, k4 = key4;
      Corner k = Corner.of_kv(kv);
      switch (i)
      {
        case 0: k0 = k; break;
        case 1: k1 = k; break;
        case 2: k2 = k; break;
        case 3: k3 = k; break;
        case 4: k4 = k; break;
      }
      return new Key(k0, k1, k2, k3, k4, width, shift, edgekeys, slider,
          indication);
    }

    public Key withShift(float s)
    {
      return new Key(key0, key1, key2, key3, key4, width, s, edgekeys, slider,
          indication);
    }

    /**
     * See Pointers.onTouchMove() for the represented direction.
     */
    public KeyValue getAtDirection(int direction)
    {
      Corner c = null;
      if (edgekeys)
      {
        // \ 1 /
        //  \ /
        // 3 0 2
        //  / \
        // / 4 \
        switch (direction)
        {
          case 2: case 3: c = key1; break;
          case 4: case 5: c = key2; break;
          case 6: case 7: c = key4; break;
          case 8: case 1: c = key3; break;
        }
      }
      else
      {
        // 1 | 2
        //   |
        // --0--
        //   |
        // 3 | 4
        switch (direction)
        {
          case 1: case 2: c = key1; break;
          case 3: case 4: c = key2; break;
          case 5: case 6: c = key4; break;
          case 7: case 8: c = key3; break;
        }
      }
      return (c == null) ? null : c.kv;
    }

    public boolean hasValue(KeyValue kv)
    {
      return (hasValue(key0, kv) || hasValue(key1, kv) || hasValue(key2, kv) ||
          hasValue(key3, kv) || hasValue(key4, kv));
    }

    private static boolean hasValue(Corner c, KeyValue kv)
    {
      return (c != null && c.kv.equals(kv));
    }
  }

  public static final class Corner
  {
    public final KeyValue kv;
    /** Whether the kv is marked with the "loc " prefix. To be removed if not
        specified in the [extra_keys]. */
    public final boolean localized;

    protected Corner(KeyValue k, boolean l)
    {
      kv = k;
      localized = l;
    }

    public static Corner parse_of_attr(XmlPullParser parser, String attr) throws Exception
    {
      String name = parser.getAttributeValue(null, attr);
      boolean localized = false;

      if (name == null)
        return null;
      String name_loc = stripPrefix(name, "loc ");
      if (name_loc != null)
      {
        localized = true;
        name = name_loc;
      }
      return new Corner(KeyValue.getKeyByName(name), localized);
    }

    public static Corner of_kv(KeyValue kv)
    {
      return new Corner(kv, false);
    }

    private static String stripPrefix(String s, String prefix)
    {
      if (s.startsWith(prefix))
        return s.substring(prefix.length());
      else
        return null;
    }
  }

  // Not using Function<KeyValue, KeyValue> to keep compatibility with Android 6.
  public static abstract interface MapKey {
    public Key apply(Key k);
  }

  public static abstract class MapKeyValues implements MapKey {
    abstract public KeyValue apply(KeyValue c, boolean localized);

    public Key apply(Key k)
    {
      return new Key(apply(k.key0), apply(k.key1), apply(k.key2),
          apply(k.key3), apply(k.key4), k.width, k.shift, k.edgekeys,
          k.slider, k.indication);
    }

    protected Corner apply(Corner c)
    {
      if (c == null)
        return null;
      KeyValue kv = apply(c.kv, c.localized);
      return (kv == null) ? null : new Corner(kv, c.localized);
    }
  }

  /** Parsing utils */

  /** Returns [false] on [END_DOCUMENT] or [END_TAG], [true] otherwise. */
  private static boolean expect_tag(XmlPullParser parser, String name) throws Exception
  {
    int status;
    do
    {
      status = parser.next();
      if (status == XmlPullParser.END_DOCUMENT || status == XmlPullParser.END_TAG)
        return false;
    }
    while (status != XmlPullParser.START_TAG);
    if (!parser.getName().equals(name))
      throw new Exception("Unknow tag: " + parser.getName());
    return true;
  }

  private static boolean attribute_bool(XmlPullParser parser, String attr, boolean default_val)
  {
    String val = parser.getAttributeValue(null, attr);
    if (val == null)
      return default_val;
    return val.equals("true");
  }

  private static float attribute_float(XmlPullParser parser, String attr, float default_val)
  {
    String val = parser.getAttributeValue(null, attr);
    if (val == null)
      return default_val;
    return Float.parseFloat(val);
  }
}
