hyphenation test

[bioacid.git] / bioacid.d

/* coded by Ketmar // Invisible Vector <ketmar@ketmar.no-ip.org>
 * Understanding is not required. Only obedience.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
module bioacid is aliced;

import std.datetime;

import arsd.color;
import arsd.image;
import arsd.simpledisplay;

import iv.cmdcon;
import iv.cmdcon.gl;
import iv.nanovega;
import iv.nanovega.blendish;
import iv.nanovega.textlayouter;
import iv.strex;
import iv.tox;
import iv.txtser;
import iv.utfutil;
import iv.vfs.io;


// ////////////////////////////////////////////////////////////////////////// //
alias LayTextClass = LayTextD;


// ////////////////////////////////////////////////////////////////////////// //
__gshared string accBaseDir = ".";

__gshared NVGContext nvg = null;
__gshared int nvgSkullsImg = 0;

__gshared LayFontStash laf;
__gshared LayTextClass lay;

__gshared int optCListWidth = -1;
__gshared int lastWindowWidth = -1;


// ////////////////////////////////////////////////////////////////////////// //
enum TTFontStyle : ubyte { Normal = 0, Italic = 1, Bold = 2 }

__gshared int uiFont, galmapFont;
__gshared int[4] textFontId;
__gshared int[4] monoFontId;
__gshared int[4] uiFontId;

__gshared string[4] textFontNames = [
  "PT Sans:noaa", //"Arial:noaa", //"~/ttf/ms/arial.ttf:noaa", // normal
  "PT Sans:italic:noaa", //"~/ttf/ms/ariali.ttf:noaa", // italic
  "PT Sans:bold:noaa", //"~/ttf/ms/arialbd.ttf:noaa", // bold
  "PT Sans:italic:bold:noaa", //"~/ttf/ms/arialbi.ttf:noaa", // italic+bold
];
__gshared string[4] monoFontNames = [
  //"/usr/share/fonts/ms/andalemo.ttf:noaa", // normal
  "PT Mono:noaa", //"Courier New:noaa", //"~/ttf/ms/cour.ttf:noaa", // normal
  "PT Mono:italic:noaa", //"~/ttf/ms/couri.ttf:noaa", // italic
  "PT Mono:bold:noaa", //"~/ttf/ms/courbd.ttf:noaa", // bold
  "PT Mono:italic:bold:noaa", //"~/ttf/ms/courbi.ttf:noaa", // italic+bold
];
__gshared string[4] uiFontNames = [
  "PT Sans:noaa", //"Arial:noaa", //"~/ttf/ms/verdana.ttf:noaa", // normal
  "PT Sans:italic:noaa", //"~/ttf/ms/ariali.ttf:noaa", // italic
  "PT Sans:bold:noaa", //"~/ttf/ms/arialbd.ttf:noaa", // bold
  "PT Sans:italic:bold:noaa", //"~/ttf/ms/arialbi.ttf:noaa", // italic+bold
];


void loadFonts (NVGContext vg) {
  void loadFont (ref int fid, string name, string path) {
    fid = vg.createFont(name, path);
    if (fid < 0) assert(0, "can't load font '"~name~"' from '"~path~"'");
    //conwriteln("created font [", name, "] (", path, "): ", fid);
  }

  void loadFontSet (string namebase, int[] ids, string[] pathes) {
    static immutable string[4] pfx = ["", "i", "b", "ib"];
    assert(ids.length >= 4);
    assert(pathes.length >= 4);
    foreach (immutable idx; 0..4) loadFont(ids[idx], namebase~pfx[idx], pathes[idx]);
  }

  loadFontSet("text", textFontId[], textFontNames[]);
  loadFontSet("mono", monoFontId[], monoFontNames[]);

  loadFontSet("ui", uiFontId[], uiFontNames[]);

  bndSetFont(uiFont);
}


// ////////////////////////////////////////////////////////////////////////// //
private void loadFmtFonts () {
  laf = new LayFontStash(nvg);

  void loadFontSet (string namebase, string[] pathes) {
    static immutable string[4] pfx = ["", "i", "b", "ib"];
    assert(pathes.length >= 4);
    foreach (immutable idx; 0..4) laf.addFont(namebase~pfx[idx], pathes[idx]);
  }

  /*if (laf.ownsFontContext)*/ {
    loadFontSet("text", textFontNames[]);
    loadFontSet("mono", monoFontNames[]);
  }
}


// ////////////////////////////////////////////////////////////////////////// //
static immutable uint[256] ctiOffline = [
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x26262626U,0xb0272427U,0xec262526U,0xec262526U,0xb2262626U,0x27262626U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x1c2b202bU,0xee272527U,0xff272527U,0xff000030U,0xff000033U,0xff272527U,0xee272527U,0x1c2b202bU,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x95262626U,0xff272527U,0xff00007dU,0xff0000fdU,0xff0000fdU,0xff000084U,0xff272527U,0x95262626U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0xcc262526U,0xff000029U,0xff0000fdU,0xff0000fdU,0xff0000fdU,0xff0000fdU,0xff000028U,0xcc262526U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0xe0272527U,0xfc272527U,0xff0000beU,0xff0000fdU,0xff0000fdU,0xff0000f8U,0xf2262526U,0xe0272527U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x3f282428U,0xe8272527U,0xff272527U,0xff00002eU,0xff000051U,0xff0000a9U,0xff00007fU,0xff272527U,0xe8272527U,0x3e262626U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x3c262626U,0xf2272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff000041U,0xfd272527U,0xff272527U,0xff272527U,0xff272527U,0xf3272527U,0x3a292329U,0x00000000U,
  0x00000000U,0x9d262526U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff000034U,0xff000034U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0x9c262626U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff000045U,0xff0000fdU,0xff0000fdU,0xff000045U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff000063U,0xff0000fdU,0xff0000fdU,0xff000063U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff00002cU,0xff0000c8U,0xff0000c3U,0xff00002cU,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff000067U,0xff0000fdU,0xff0000fdU,0xff00005fU,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff000029U,0xff0000fdU,0xff0000fdU,0xff0000fdU,0xff0000fbU,0xff000025U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff000031U,0xff0000fdU,0xff0000fdU,0xff0000fdU,0xff0000f8U,0xff000026U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0x8c272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff000031U,0xff000036U,0xff000036U,0xff000030U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0x8a272527U,0x00000000U,
  0x00000000U,0x25262626U,0xc0262626U,0xfe272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xc2262526U,0x21262626U,0x00000000U,
];

static immutable uint[256] ctiOnline = [
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x26262626U,0xb0272427U,0xec262526U,0xec262526U,0xb2262626U,0x27262626U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x1c2b202bU,0xee272527U,0xff272527U,0xff003000U,0xff003300U,0xff272527U,0xee272527U,0x1c2b202bU,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x95262626U,0xff272527U,0xff007d00U,0xff00fd00U,0xff00fd00U,0xff008400U,0xff272527U,0x95262626U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0xcc262526U,0xff002900U,0xff00fd00U,0xff00fd00U,0xff00fd00U,0xff00fd00U,0xff002800U,0xcc262526U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0xe0272527U,0xfc272527U,0xff00be00U,0xff00fd00U,0xff00fd00U,0xff00f800U,0xf2262526U,0xe0272527U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x3f282428U,0xe8272527U,0xff272527U,0xff002e00U,0xff005100U,0xff00a900U,0xff007f00U,0xff272527U,0xe8272527U,0x3e262626U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x3c262626U,0xf2272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff004100U,0xfd272527U,0xff272527U,0xff272527U,0xff272527U,0xf3272527U,0x3a292329U,0x00000000U,
  0x00000000U,0x9d262526U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff003400U,0xff003400U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0x9c262626U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff004500U,0xff00fd00U,0xff00fd00U,0xff004500U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff006300U,0xff00fd00U,0xff00fd00U,0xff006300U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff002c00U,0xff00c800U,0xff00c300U,0xff002c00U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff006700U,0xff00fd00U,0xff00fd00U,0xff005f00U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff002900U,0xff00fd00U,0xff00fd00U,0xff00fd00U,0xff00fb00U,0xff002500U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff003100U,0xff00fd00U,0xff00fd00U,0xff00fd00U,0xff00f800U,0xff002600U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0x8c272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff003100U,0xff003600U,0xff003600U,0xff003000U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0x8a272527U,0x00000000U,
  0x00000000U,0x25262626U,0xc0262626U,0xfe272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xc2262526U,0x21262626U,0x00000000U,
];

static immutable uint[256] ctiAway = [
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x26262626U,0xb0272427U,0xec262526U,0xec262526U,0xb2262626U,0x27262626U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x1c2b202bU,0xee272527U,0xff272527U,0xff230d13U,0xff260d14U,0xff272527U,0xee272527U,0x1c2b202bU,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0x95262626U,0xff272527U,0xff5c2131U,0xffb94362U,0xffb94362U,0xff602333U,0xff272527U,0x95262626U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0xcc262526U,0xff1e0b10U,0xffb94362U,0xffb94362U,0xffb94362U,0xffb94362U,0xff1d0b0fU,0xcc262526U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x00000000U,0xe0272527U,0xfc272527U,0xff8b324aU,0xffb94362U,0xffb94362U,0xffb54260U,0xf2262526U,0xe0272527U,0x00000000U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x00000000U,0x00000000U,0x3f282428U,0xe8272527U,0xff272527U,0xff220c12U,0xff3b161fU,0xff7b2d41U,0xff5c2231U,0xff272527U,0xe8272527U,0x3e262626U,0x00000000U,0x00000000U,0x00000000U,
  0x00000000U,0x3c262626U,0xf2272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff2f1119U,0xfd272527U,0xff272527U,0xff272527U,0xff272527U,0xf3272527U,0x3a292329U,0x00000000U,
  0x00000000U,0x9d262526U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff260e14U,0xff260e14U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0x9c262626U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff32121aU,0xffb94362U,0xffb94362U,0xff32121aU,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff491a26U,0xffb94362U,0xffb94362U,0xff491a26U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff200c11U,0xff92354dU,0xff8e344bU,0xff200c11U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff4b1b28U,0xffb94362U,0xffb94362U,0xff461925U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff1e0b10U,0xffb94362U,0xffb94362U,0xffb94362U,0xffb74361U,0xff1b0a0eU,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0xb0272427U,0xff272527U,0xff272527U,0xff272527U,0xff240d13U,0xffb94362U,0xffb94362U,0xffb94362U,0xffb54260U,0xff1c0a0fU,0xff272527U,0xff272527U,0xff272527U,0xb0272427U,0x00000000U,
  0x00000000U,0x8c272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff240d13U,0xff280e15U,0xff280e15U,0xff230d13U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0x8a272527U,0x00000000U,
  0x00000000U,0x25262626U,0xc0262626U,0xfe272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xff272527U,0xc2262526U,0x21262626U,0x00000000U,
];


__gshared int[3] statusImgId;

//enum Status { Offline, Online, Away }
void buildStatusImages () {
  statusImgId[0] = nvg.createImageRGBA(16, 16, ctiOffline[], NVGImageFlags.NoFiltering);
  statusImgId[1] = nvg.createImageRGBA(16, 16, ctiOnline[], NVGImageFlags.NoFiltering);
  statusImgId[2] = nvg.createImageRGBA(16, 16, ctiAway[], NVGImageFlags.NoFiltering);
}


// ////////////////////////////////////////////////////////////////////////// //
//vg.fillColor(NVGColor.orange);
void drawLayouter(LT) (NVGContext vg, LT lay, int layTopY, int x0, int y0, int hgt) if (is(LT : LayTextImpl!CT, CT)) {
  if (vg is null || lay is null || hgt < 1 || lay.lineCount == 0 || lay.width < 1) return;
  int drawY = y0;
  //FIXME: not GHeight!
  int lidx = lay.findLineAtY(layTopY);
  if (lidx >= 0 && lidx < lay.lineCount) {
    vg.save();
    scope(exit) vg.restore();
    vg.intersectScissor(x0, y0, lay.width, hgt);
    drawY -= layTopY-lay.line(lidx).y;
    vg.textAlign(NVGTextAlign.H.Left, NVGTextAlign.V.Baseline);
    LayFontStyle lastStyle;
    int startx = x0;
    bool setColor = true;
    while (lidx < lay.lineCount && hgt > 0) {
      auto ln = lay.line(lidx);
      foreach (ref LayWord w; lay.lineWords(lidx)) {
        if (lastStyle != w.style || setColor) {
          if (w.style.fontface != lastStyle.fontface) vg.fontFace(lay.fontFace(w.style.fontface));
          vg.fontSize(w.style.fontsize);
          auto c = NVGColor(w.style.color);
          vg.fillColor(c);
          lastStyle = w.style;
          setColor = false;
          //conprintfln("new color: 0x%08x; fontid=%d; fontsize=%d", w.style.color, w.style.fontface, w.style.fontsize);
        }
        // background color
        {
          auto c = NVGColor(w.style.bgcolor);
          if (!c.isTransparent) {
            vg.save();
            scope(exit) vg.restore();
            vg.beginPath();
            vg.fillColor(c);
            vg.rect(startx+w.x+0.5f, drawY+0.5, w.fullwidth+1, ln.h);
            vg.fill();
            vg.beginPath();
          }
        }
        // element
        auto oid = w.objectIdx;
        if (oid >= 0) {
          //vg.fill();
          vg.save();
          scope(exit) vg.restore();
          lay.objectAtIndex(oid).draw(vg, startx+w.x, drawY+ln.h+ln.desc);
          //vg.beginPath();
        } else if (!w.expander) {
          vg.text(startx+w.x, drawY+ln.h+ln.desc, lay.wordText(w));
        }
        //TODO: draw lines over whitespace
        if (lastStyle.underline) vg.rect(startx+w.x+0.5f, drawY+ln.h+ln.desc+1+0.5f, w.w, 1);
        if (lastStyle.strike) vg.rect(startx+w.x+0.5f, drawY+ln.h+ln.desc-w.asc/3+0.5f, w.w, 2);
        if (lastStyle.overline) vg.rect(startx+w.x+0.5f, drawY+ln.h+ln.desc-w.asc-1+0.5f, w.w, 1);
      }
      drawY += ln.h;
      hgt -= ln.h;
      ++lidx;
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
enum TriOption { Default = -1, No = 0, Yes = 1 }


// ////////////////////////////////////////////////////////////////////////// //
struct CommonOptions {
  TriOption showOffline = TriOption.Default; // show this contact even if it is offline
  TriOption showPopup = TriOption.Default; // show popups for messages from this contact
  TriOption blinkActivity = TriOption.Default; // blink tray icon if we have some activity for this contact
  TriOption skipUnread = TriOption.Default; // skip this contacts in `next_unread` command
  TriOption ftranAllowed = TriOption.Default; // file transfers allowed for this contact
  int resendRotDays = -1; // how many days message should be in "resend queue" if contact is offline (-1: use default value)
  int hmcOnOpen = -1; // how many history messages we should show when we opening a chat with a contact (-1: use default value)
  //@SRZNonDefaultOnly TriOption confAutoJoin; // automatically join the conference when we're going online
}


struct ProtoOptions {
  bool ipv6;
  bool udp;
  bool localDiscovery;
  bool holePunching;
  ushort startPort;
  ushort endPort;
  ushort tcpPort;
  ubyte proxyType;
  ushort proxyPort;
  string proxyAddr;
}


struct AccountConfig {
  string nick; // my nick
  string statusmsg; // my status message
  bool showOffline; // show offline persons?
  bool showPopup; // show popups for messages?
  bool blinkActivity; // blink tray icon if we have some activity (unread msg, transfer request, etc.)?
  bool skipUnread; // skip contacts in `next_unread` command?
  bool hideEmptyGroups; // hide empty groups? (can be overriden by `hideNoVisible` group option)
  bool ftranAllowed; // file transfers allowed for this group (-1: use default value)
  int resendRotDays; // how many days message should be in "resend queue" if contact is offline
  int hmcOnOpen; // how many history messages we should show when we opening a chat with a contact
}


struct GroupOptions {
  uint gid; // group id; there is always group with gid 0, it is "common" default group
  string name; // group name
  string note; // group notes/description
  bool opened; // is this group opened?
  TriOption showOffline = TriOption.Default; // show offline persons in this group
  TriOption showPopup = TriOption.Default; // show popups for messages from this group
  TriOption blinkActivity = TriOption.Default; // blink tray icon if we have some activity (unread msg, transfer request, etc.) for this group
  TriOption skipUnread = TriOption.Default; // skip contacts from this group in `next_unread` command
  TriOption hideIfNoVisibleMembers = TriOption.Default; // hide this group if there are no visible items in it
  TriOption ftranAllowed; // file transfers allowed for this group
  int resendRotDays = -1; // how many days message should be in "resend queue" if contact is offline (-1: use default value)
  int hmcOnOpen = -1; // how many history messages we should show when we opening a chat with a contact (-1: use default value)
}


alias PubKey = ubyte[32];

struct ContactInfo {
  enum Kind {
    // normal contact
    Friend,
    // pending authorization acceptance
    //   statusmsg: request text
    //   lastonlinetime: request time
    PengingAuthAccept,
    // auth requested, awaiting acceptance
    //   statusmsg: request text
    //   lastonlinetime: request time
    // this will change to `Friend` when contact gets online (it means that auth is accepted)
    PengingAuthRequest,
    // this contact was deleted and put in "total ignore" mode
    // i.e. any activity from this contact (especially auth requests) will be silently dropped on the floor
    KillFuckDie,
  }
  uint gid; // group id (see groups.rc)
  string nick; // empty: unauthorized
  @SRZNonDefaultOnly string visnick; // empty: use `nick`
  @SRZNonDefaultOnly string statusmsg;
  @SRZNonDefaultOnly uint lastonlinetime; // local unixtime; changed when contact status changed between offline and online (any kind of online)
  Kind kind = Kind.Friend;
  string note; // contact notes/description
  PubKey pubkey; // used as unique contact id, same as directory name
  CommonOptions opts;
}


// ////////////////////////////////////////////////////////////////////////// //
void syncFile(bool fullsync=false) (Imp!"core.stdc.stdio".FILE* fl) nothrow @nogc {
  if (fl !is null) {
    import core.stdc.stdio : fileno;
    int fd = fileno(fl);
    if (fd >= 0) {
      import core.sys.posix.unistd : fsync, fdatasync;
      static if (fullsync) fsync(fd); else fdatasync(fd);
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// write to temporary file, then atomically replace
bool serialize(T) (in auto ref T v, string fname) {
  import core.stdc.stdio : FILE, fopen, fclose, rename;
  import core.sys.posix.unistd : unlink;
  import std.internal.cstring;

  string tmpfname = fname~".$$$";
  FILE* fo = fopen(tmpfname.tempCString, "w");
  if (fo is null) return false;

  try {
    v.txtser(VFile(fo, own:false), skipstname:true);
  } catch (Exception e) {
    fclose(fo);
    unlink(tmpfname.tempCString);
    return false;
  }
  syncFile(fo);
  fclose(fo);

  if (rename(tmpfname.tempCString, fname.tempCString) != 0) {
    unlink(tmpfname.tempCString);
    return false;
  }

  return true;
}


// ////////////////////////////////////////////////////////////////////////// //
/*
  log format (it looks like text, but it isn't text):
  T[YYYY/MM/DD HH:NN:SS]: text-in-utf8
  date in local time.
  text: chars in range of [0..31, 92, 127] are \xHH-encoded
  T is message type:
    !: server/app notification
    <: outgoing
    >: incoming
  if char before text is '!' instead of space, this is "/me" message
*/
static struct LogFile {
public:
  // this struct must not outlive LogFile
  static struct Msg {
    enum Kind { Notification, Incoming, Outgoing }
    Kind kind;
    bool isMe; // "/me" message?
    SysTime time;
    char[] rawText; // undecoded

    // decode raw text to dchars; returns forward range
    auto byDChar () const nothrow @safe @nogc {
      static struct Range {
      pure nothrow @trusted @nogc:
        const(char)[] raw; // anchored
        usize pos;
        @property bool empty () const => (pos >= raw.length);
        @property dchar front () const {
          if (pos < raw.length) {
            char ch = raw.ptr[pos];
            if (ch <= 127) {
              if (ch != '\\') return ch;
              if (raw.length-pos < 2) return ch;
              ch = raw.ptr[pos+1];
              if (ch != 'x' && ch != 'X') {
                switch (ch) {
                  case 'e': return '\e';
                  case 'n': return '\n';
                  case 'r': return '\r';
                  case 't': return '\t';
                  default:
                }
                return ch;
              }
              if (raw.length-pos < 4) return '?';
              int n0 = raw.ptr[pos+2].digitInBase(16);
              if (n0 < 0) return '?';
              int n1 = raw.ptr[pos+3].digitInBase(16);
              if (n1 < 0) return '?';
              return cast(char)(n0*16+n1);
            }
            Utf8DecoderFast dc;
            uint cpos = pos;
            while (!dc.decode(cast(ubyte)raw.ptr[cpos++])) {
              if (cpos >= raw.length) break; // no more chars
            }
            return (dc.complete ? dc.codepoint : dc.replacement);
          } else {
            return Utf8DecoderFast.replacement;
          }
        }
        void popFront () {
          if (pos < raw.length) {
            char ch = raw.ptr[pos];
            if (ch <= 127) {
              ++pos;
              if (ch != '\\') return;
              if (raw.length-pos < 1) { pos = raw.length; return; }
              ch = raw.ptr[pos++];
              if (ch != 'x' && ch != 'X') return;
              if (raw.length-pos < 2) { pos = raw.length; return; }
              pos += 2;
              return;
            }
            Utf8DecoderFast dc;
            while (!dc.decode(cast(ubyte)raw.ptr[pos++])) {
              if (pos >= raw.length) break; // no more chars
            }
          }
        }
        Range save () const => Range(raw, pos);
      }
      return Range(rawText, 0);
    }
  }

private:
  char[] data;

public:
  Msg[] messages;

public:
  @disable this (this); // no copies

  this (const(char)[] fname) nothrow => load(fname);

  ~this () nothrow {
    clear();
  }

  // no `Msg` should outlive this call!
  void clear () nothrow {
    delete messages;
    delete data;
  }

  void load (const(char)[] fname) nothrow {
    import std.internal.cstring;

    if (messages.length) {
      messages.length = 0;
      messages.assumeSafeAppend;
    }
    if (data.length) {
      data.length = 0;
      data.assumeSafeAppend;
    }

    if (fname.length == 0) return;

    try {
      auto fi = VFile(fname);
      if (fi.size > int.max/8) assert(0, "log file too big");
      data.length = cast(int)fi.size;
      fi.rawReadExact(data);
    } catch (Exception e) {}

    parseData();
  }

  // `data` should be set
  private void parseData () nothrow {
    import core.stdc.string : memchr;

    assert(messages.length == 0); // sorry
    if (data.length == 0) return;

    // count '\n'
    int nlcount = 0;
    {
      auto dp = data.ptr;
      while (dp < data.ptr+data.length) {
        auto nx = cast(char*)memchr(dp, '\n', data.length-(dp-data.ptr));
        if (nx is null) break;
        ++nlcount;
        dp = nx+1;
      }
    }
    messages.reserve(nlcount+1);

    static int toInt (const(char)[] s) nothrow @trusted @nogc {
      int res = 0;
      while (s.length && s.ptr[0].isdigit) {
        res = res*10+s.ptr[0]-'0';
        s = s[1..$];
      }
      return res;
    }

    // parse messages
    auto dp = data.ptr, nx = data.ptr+data.length;
    for (; dp < data.ptr+data.length; dp = nx+1) {
      nx = cast(char*)memchr(dp, '\n', data.length-(dp-data.ptr));
      if (nx is null) nx = data.ptr+data.length;
      // 25 is the minimal message length
      if (nx-dp < 25) continue;
      if (dp[1] != '[' || dp[6] != '/' || dp[9] != '/' || dp[12] != ' ' || dp[15] != ':' || dp[18] != ':' || dp[21] != ']' || dp[22] != ':') continue;
      foreach (immutable cidx, immutable char ch; dp[0..21]) {
        if (cidx < 2 || cidx == 6 || cidx == 9 || cidx == 12 || cidx == 15 || cidx == 18) continue;
        if (!ch.isdigit) continue;
      }
      Msg msg;
      // message kind
      switch (dp[0]) {
        case '!': msg.kind = msg.Kind.Notification; break;
        case '<': msg.kind = msg.Kind.Outgoing; break;
        case '>': msg.kind = msg.Kind.Incoming; break;
        default: continue;
      }
      // "/me"?
      switch (dp[23]) {
        case ' ': msg.isMe = false; break;
        case '!': msg.isMe = true; break;
        default: continue;
      }
      int year = toInt(dp[2..6]);
      if (year < 2018 || year > 2036) continue; //FIXME in 2036! ;-)
      int month = toInt(dp[7..9]);
      if (month < 1 || month > 12) continue;
      int day = toInt(dp[10..12]);
      if (day < 1 || day > 31) continue;
      int hour = toInt(dp[13..15]);
      if (hour < 0 || hour > 23) continue;
      int minute = toInt(dp[16..18]);
      if (minute < 0 || minute > 59) continue;
      int second = toInt(dp[19..21]);
      if (second < 0 || second > 59) continue;
      bool timeok = false;
      try {
        msg.time = SysTime(DateTime(year, month, day, hour, minute, second));
        timeok = true;
      } catch (Exception e) {}
      if (!timeok) continue;
      msg.rawText = dp[24..(nx-dp)];
      messages ~= msg;
    }
  }

public:
  // append line to log file; text is in utf8
  // WARNING! does no validity checks!
  static bool appendLine (const(char)[] fname, LogFile.Msg.Kind kind, const(char)[] text, bool isMe, SysTime time) nothrow {
    import core.stdc.stdio : FILE, fopen, fclose, fwrite;
    import std.internal.cstring;

    if (fname.length == 0) return false;

    FILE* fo = fopen(fname.tempCString, "a");
    if (fo is null) return false;
    scope(exit) { syncFile(fo); fclose(fo); }

    bool xwrite (const(char)[] s...) nothrow @nogc {
      while (s.length > 0) {
        auto wr = fwrite(s.ptr, 1, s.length, fo);
        if (wr == 0) {
          import core.stdc.errno;
          if (errno != EINTR) return false;
          continue;
        }
        s = s[wr..$];
      }
      return true;
    }

    bool wrnum (int n, int wdt) nothrow @nogc {
      import core.stdc.stdio : snprintf;
      if (n < 0) return false; // alas
      char[128] buf = void;
      auto len = (wdt > 0 ? snprintf(buf.ptr, buf.length, "%0*d", wdt, n) : snprintf(buf.ptr, buf.length, "%d", n));
      if (len < 1) return false;
      return xwrite(buf[0..len]);
    }

    final switch (kind) {
      case LogFile.Msg.Kind.Notification: if (!xwrite("!")) return false; break;
      case LogFile.Msg.Kind.Incoming: if (!xwrite(">")) return false; break;
      case LogFile.Msg.Kind.Outgoing: if (!xwrite("<")) return false; break;
    }

    // write date
    auto dt = cast(DateTime)time;
    if (!xwrite("[")) return false;
    if (!wrnum(dt.year, 4)) return false;
    if (!xwrite("/")) return false;
    if (!wrnum(cast(int)dt.month, 2)) return false;
    if (!xwrite("/")) return false;
    if (!wrnum(dt.day, 2)) return false;
    if (!xwrite(" ")) return false;
    if (!wrnum(dt.hour, 2)) return false;
    if (!xwrite(":")) return false;
    if (!wrnum(dt.minute, 2)) return false;
    if (!xwrite(":")) return false;
    if (!wrnum(dt.second, 2)) return false;
    if (!xwrite("]:")) return false;
    if (!xwrite(isMe ? "!" : " ")) return false;

    // write encoded string
    while (text.length) {
      usize end = 0;
      while (end < text.length) {
        char ch = text.ptr[end];
        if (ch < ' ' || ch == 92 || ch == 127) break;
        ++end;
      }
      if (end > 0) {
        if (!xwrite(text[0..end])) return false;
        text = text[end..$];
      } else {
        switch (text.ptr[0]) {
          case '\e': if (!xwrite(`\e`)) return false; break;
          case '\n': if (!xwrite(`\n`)) return false; break;
          case '\r': if (!xwrite(`\r`)) return false; break;
          case '\t': if (!xwrite(`\t`)) return false; break;
          default:
            import core.stdc.stdio : snprintf;
            char[16] buf = void;
            auto len = snprintf(buf.ptr, buf.length, "\\x%02x", cast(uint)text.ptr[0]);
            if (!xwrite(buf[0..len])) return false;
            break;
        }
        text = text[1..$];
      }
    }

    return xwrite("\n");
  }

  // append line to log file; text is in utf8
  // WARNING! does no validity checks!
  static bool appendLine (const(char)[] fname, LogFile.Msg.Kind kind, const(char)[] text, bool isMe=false) nothrow {
    try {
      return appendLine(fname, kind, text, isMe, Clock.currTime);
    } catch (Exception e) {}
    return false;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final class Group {
private:
  this (Account aOwner) { acc = aOwner; }

private:
  bool mDirty; // true: write contact's config
  string diskFileName;

public:
  Account acc;
  GroupOptions info;

public:
  void markDirty () pure nothrow @safe @nogc => mDirty = true;

  void save () {
    import std.file : mkdirRecurse;
    import std.path : dirName;
    // save this contact
    assert(acc !is null);
    // create disk name
    if (diskFileName.length == 0) {
      diskFileName = acc.basePath~"/contacts/groups.rc";
    }
    mkdirRecurse(diskFileName.dirName);
    if (serialize(info, diskFileName)) mDirty = false;
  }

  @property bool visible () const nothrow @trusted @nogc {
    if (!hideIfNoVisibleMembers) return true; // always visible
    // check if we have any visible members
    foreach (const(Contact) c; acc.contacts.byValue) {
      if (c.gid != info.gid) continue;
      if (c.visibleNoGroupCheck) return true;
    }
    return false; // nobody's here
  }

  private bool getTriOpt(string fld, string fld2=null) () const nothrow @trusted @nogc {
    enum lo = "info."~fld;
    if (mixin(lo) != TriOption.Default) return (mixin(lo) == TriOption.Yes);
    static if (fld2.length) return mixin("acc.info."~fld2); else return mixin("acc.info."~fld);
  }

  private int getIntOpt(string fld) () const nothrow @trusted @nogc {
    enum lo = "info."~fld;
    if (mixin(lo) >= 0) return mixin(lo);
    return mixin("acc.info."~fld);
  }

  @property nothrow @safe {
    uint gid () const pure @nogc => info.gid;

    bool opened () const @nogc => info.opened;
    void opened (bool v) @nogc { pragma(inline, true); if (info.opened != v) { info.opened = v; markDirty(); } }

    string name () const @nogc => info.name;
    void name (string v) @nogc { pragma(inline, true); if (v.length == 0) v = "<unnamed>"; if (info.name != v) { info.name = v; markDirty(); } }

    string note () const @nogc => info.note;
    void note (string v) @nogc { pragma(inline, true); if (info.note != v) { info.note = v; markDirty(); } }

    @nogc {
      bool showOffline () const => getTriOpt!"showOffline";
      bool showPopup () const => getTriOpt!"showPopup";
      bool blinkActivity () const => getTriOpt!"blinkActivity";
      bool skipUnread () const => getTriOpt!"skipUnread";
      bool hideIfNoVisibleMembers () const => getTriOpt!("hideIfNoVisibleMembers", "hideEmptyGroups");
      bool ftranAllowed () const => getTriOpt!"ftranAllowed";
      int resendRotDays () const => getIntOpt!"resendRotDays";
      int hmcOnOpen () const => getIntOpt!"hmcOnOpen";
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final class Contact {
public:
  enum Status { Offline, Online, Away }

private:
  this (Account aOwner) { acc = aOwner; }

private:
  bool mDirty; // true: write contact's config

public:
  Account acc;
  string diskFileName;
  ContactInfo info;
  Status status = Status.Offline; // not saved, so if it safe to change it

public:
  void markDirty () pure nothrow @safe @nogc => mDirty = true;

  void save () {
    import std.file : mkdirRecurse;
    import std.path : dirName;
    // save this contact
    assert(acc !is null);
    // create disk name
    if (diskFileName.length == 0) {
      diskFileName = acc.basePath~"/contacts/"~tox_hex(info.pubkey[])~"/config.rc";
      acc.contacts[info.pubkey] = this;
    }
    mkdirRecurse(diskFileName.dirName);
    mkdirRecurse(diskFileName.dirName~"/avatars");
    mkdirRecurse(diskFileName.dirName~"/files");
    mkdirRecurse(diskFileName.dirName~"/fileparts");
    mkdirRecurse(diskFileName.dirName~"/logs");
    if (serialize(info, diskFileName)) mDirty = false;
  }

public:
  @property bool visibleNoGroupCheck () const nothrow @trusted @nogc => (showOffline || status != Status.Offline);

  @property bool visible () const nothrow @trusted @nogc {
    if (!showOffline && status == Status.Offline) return false;
    auto grp = acc.groupById(gid);
    return grp.visible;
  }

  @property nothrow @safe {
    ContactInfo.Kind kind () const @nogc => info.kind;
    void kind (ContactInfo.Kind v) @nogc { pragma(inline, true); if (info.kind != v) { info.kind = v; markDirty(); } }

    uint gid () const @nogc => info.gid;
    void gid (uint v) @nogc { pragma(inline, true); if (info.gid != v) { info.gid = v; markDirty(); } }

    string nick () const @nogc => info.nick;
    void nick (string v) @nogc { pragma(inline, true); if (v.length == 0) v = "<unknown>"; if (info.nick != v) { info.nick = v; markDirty(); } }

    string visnick () const @nogc => info.visnick;
    void visnick (string v) @nogc { pragma(inline, true); if (info.visnick != v) { info.visnick = v; markDirty(); } }

    string displayNick () const @nogc => (info.visnick.length ? info.visnick : info.nick);

    string statusmsg () const @nogc => info.statusmsg;
    void statusmsg (string v) @nogc { pragma(inline, true); if (info.statusmsg != v) { info.statusmsg = v; markDirty(); } }

    void setLastOnlineNow () {
      try {
        auto ut = Clock.currTime.toUTC().toUnixTime();
        if (info.lastonlinetime != cast(uint)ut) { info.lastonlinetime = cast(uint)ut; markDirty(); }
      } catch (Exception e) {}
    }

    string note () const @nogc => info.note;
    void note (string v) @nogc { pragma(inline, true); if (info.note != v) { info.note = v; markDirty(); } }
  }

  private bool getTriOpt(string fld) () const nothrow @trusted @nogc {
    enum lo = "info.opts."~fld;
    if (mixin(lo) != TriOption.Default) return (mixin(lo) == TriOption.Yes);
    auto grp = acc.groupById(info.gid);
    enum go = "grp.info."~fld;
    if (mixin(go) != TriOption.Default) return (mixin(go) == TriOption.Yes);
    return mixin("acc.info."~fld);
  }

  private int getIntOpt(string fld) () const nothrow @trusted @nogc {
    enum lo = "info.opts."~fld;
    if (mixin(lo) >= 0) return mixin(lo);
    auto grp = acc.groupById(info.gid);
    enum go = "grp.info."~fld;
    if (mixin(go) >= 0) return mixin(go);
    return mixin("acc.info."~fld);
  }

  @property nothrow @safe @nogc {
    bool showOffline () const => getTriOpt!"showOffline";
    bool showPopup () const => getTriOpt!"showPopup";
    bool blinkActivity () const => getTriOpt!"blinkActivity";
    bool skipUnread () const => getTriOpt!"skipUnread";
    bool ftranAllowed () const => getTriOpt!"ftranAllowed";
    int resendRotDays () const => getIntOpt!"resendRotDays";
    int hmcOnOpen () const => getIntOpt!"hmcOnOpen";
  }
}


// ////////////////////////////////////////////////////////////////////////// //
final class Account {
public:
  void saveGroups () {
    import std.algorithm : sort;
    GroupOptions[] glist;
    scope(exit) delete glist;
    foreach (Group g; groups) glist ~= g.info;
    glist.sort!((in ref a, in ref b) => a.gid < b.gid);
    glist.serialize(basePath~"contacts/groups.rc");
  }

private:
  // returns `null` if there is no such file or file cannot be loaded
  ubyte[] loadToxCoreData () {
    if (toxDataDiskName.length == 0) return null;
    try {
      auto fl = VFile(toxDataDiskName);
      if (fl.size > int.max/8) throw new Exception("toxcore data corrupted");
      auto res = new ubyte[](cast(int)fl.size);
      fl.rawReadExact(res[]);
      return res[];
    } catch (Exception e) {
    }
    return null;
  }

  bool saveToxCoreData () {
    import core.stdc.stdio : FILE, fopen, fclose, rename;
    import core.stdc.stdlib : malloc, free;
    import core.sys.posix.unistd : unlink;
    import std.internal.cstring;

    if (tox is null || toxDataDiskName.length == 0) return false;

    auto size = tox_get_savedata_size(tox);
    if (size > int.max/8) return false; //throw new Exception("save data too big");

    char* savedata = cast(char*)malloc(size);
    if (savedata is null) return false;
    scope(exit) if (savedata !is null) free(savedata);

    tox_get_savedata(tox, savedata);

    auto ofname = toxDataDiskName;
    auto ofnametmp = toxDataDiskName~".$$$";
    FILE* fo = fopen(ofnametmp.tempCString, "w");
    if (fo is null) return false;
    try {
      VFile(fo, own:false).rawWriteExact(savedata[0..size]);
    } catch (Exception e) {
      unlink(ofnametmp.tempCString);
      return false;
    }
    syncFile(fo);
    fclose(fo);

    if (rename(ofnametmp.tempCString, ofname.tempCString) != 0) {
      unlink(ofnametmp.tempCString);
      return false;
    }

    return true;
  }

public:
  ToxP tox;
  string toxDataDiskName;
  string basePath; // with trailing "/"
  ProtoOptions protoOpts;
  AccountConfig info;
  Group[] groups;
  Contact[PubKey] contacts;

public:
  this (string aBaseDir) {
    import std.algorithm : sort;
    import std.file : DirEntry, SpanMode, dirEntries;
    import std.path : absolutePath, baseName;

    if (aBaseDir.length == 0 || aBaseDir == "." || aBaseDir == "./") {
      aBaseDir = "./";
    } else if (aBaseDir == "/") {
      assert(0, "wtf?!");
    } else {
      if (aBaseDir[$-1] != '/') aBaseDir ~= '/';
    }

    basePath = aBaseDir.absolutePath;
    toxDataDiskName = basePath~"toxdata.tox";
    protoOpts.txtunser(VFile(basePath~"proto.rc"));
    info.txtunser(VFile(basePath~"config.rc"));

    // load groups
    GroupOptions[] glist;
    glist.txtunser(VFile(basePath~"contacts/groups.rc"));
    bool hasDefaultGroup = false;
    bool hasMoronsGroup = false;
    foreach (ref GroupOptions gi; glist[]) {
      auto g = new Group(this);
      g.info = gi;
      bool found = false;
      foreach (ref gg; groups[]) if (gg.gid == g.gid) { delete gg; gg = g; found = true; }
      if (!found) groups ~= g;
      if (g.gid == 0) hasDefaultGroup = true;
      if (g.gid == g.gid.max) hasMoronsGroup = true;
    }

    // create default group if necessary
    if (!hasDefaultGroup) {
      GroupOptions gi;
      gi.gid = 0;
      gi.name = "default";
      gi.note = "default group for new contacts";
      gi.opened = true;
      auto g = new Group(this);
      g.info = gi;
      groups ~= g;
    }

    // create morons group if necessary
    if (!hasMoronsGroup) {
      GroupOptions gi;
      gi.gid = gi.gid.max;
      gi.name = "<morons>";
      gi.note = "group for completely ignored dumbfucks";
      gi.opened = false;
      gi.showOffline = TriOption.No;
      gi.showPopup = TriOption.No;
      gi.blinkActivity = TriOption.No;
      gi.skipUnread = TriOption.Yes;
      gi.hideIfNoVisibleMembers = TriOption.Yes;
      gi.ftranAllowed = TriOption.No;
      gi.resendRotDays = 0;
      gi.hmcOnOpen = 0;
      auto g = new Group(this);
      g.info = gi;
      groups ~= g;
      saveGroups();
    }

    groups.sort!((in ref a, in ref b) => a.gid < b.gid);

    if (!hasDefaultGroup || !hasMoronsGroup) saveGroups();

    // load contacts
    foreach (DirEntry de; dirEntries(basePath~"contacts", SpanMode.shallow)) {
      if (de.name.baseName == "." || de.name.baseName == "..") continue;
      try {
        import std.file : exists;
        if (!de.isDir) continue;
        string cfgfn = de.name~"/config.rc";
        if (!cfgfn.exists) continue;
        ContactInfo ci;
        ci.txtunser(VFile(cfgfn));
        auto c = new Contact(this);
        c.diskFileName = cfgfn;
        c.info = ci;
        contacts[c.info.pubkey] = c;
        // fix contact group
        if (groupById!false(c.gid) is null) {
          c.info.gid = 0; // move to default group
          c.save();
        }
        //conwriteln("loaded contact [", c.info.nick, "] from '", c.diskFileName, "'");
      } catch (Exception e) {
        conwriteln("ERROR loading contact from '", de.name, "/config.rc'");
      }
    }

    // create toxcore
    char* toxProxyHost = null;
    scope(exit) {
      import core.stdc.stdlib : free;
      if (toxProxyHost !is null) free(toxProxyHost);
    }
    ubyte[] savedata;
    scope(exit) delete savedata;

    auto toxOpts = tox_options_new();
    assert(toxOpts !is null);
    scope(exit) if (toxOpts !is null) tox_options_free(toxOpts);
    tox_options_default(toxOpts);

    bool createNewToxCoreAccount = false;
    toxOpts.tox_options_set_ipv6_enabled(protoOpts.ipv6);
    toxOpts.tox_options_set_udp_enabled(protoOpts.udp);
    toxOpts.tox_options_set_local_discovery_enabled(protoOpts.localDiscovery);
    toxOpts.tox_options_set_hole_punching_enabled(protoOpts.holePunching);
    toxOpts.tox_options_set_start_port(protoOpts.startPort);
    toxOpts.tox_options_set_end_port(protoOpts.endPort);
    toxOpts.tox_options_set_tcp_port(protoOpts.tcpPort);
    toxOpts.tox_options_set_proxy_type(protoOpts.proxyType);
    if (protoOpts.proxyType != TOX_PROXY_TYPE_NONE) {
      import core.stdc.stdlib : malloc;
      toxOpts.tox_options_set_proxy_port(protoOpts.proxyPort);
      // create proxy address string
      toxProxyHost = cast(char*)malloc(protoOpts.proxyAddr.length+1);
      if (toxProxyHost is null) assert(0, "out of memory");
      toxProxyHost[0..protoOpts.proxyAddr.length] = protoOpts.proxyAddr[];
      toxProxyHost[protoOpts.proxyAddr.length] = 0;
      toxOpts.tox_options_set_proxy_host(toxProxyHost);
    }
    savedata = loadToxCoreData();
    if (savedata is null) {
      // create new tox instance
      createNewToxCoreAccount = true;
      toxOpts.tox_options_set_savedata_type(TOX_SAVEDATA_TYPE_NONE);
      conwriteln("creating new ToxCore account...");
    } else {
      // load data
      toxOpts.tox_options_set_savedata_type(TOX_SAVEDATA_TYPE_TOX_SAVE);
      toxOpts.tox_options_set_savedata_length(savedata.length);
      toxOpts.tox_options_set_savedata_data(savedata.ptr, savedata.length);
    }
    // create tox instance
    TOX_ERR_NEW error;
    tox = tox_new(toxOpts, &error);
    if (tox is null) {
      import std.conv : to;
      assert(0, "cannot create ToxCore instance: error is "~error.to!string);
    }
    if (createNewToxCoreAccount) saveToxCoreData();
  }

  ~this () {
    if (tox !is null) tox_kill(tox);
  }

  // will not write contact to disk
  Contact createEmptyContact () {
    auto c = new Contact(this);
    c.info.gid = 0;
    c.info.nick = "test contact";
    c.info.pubkey[] = 0;
    return c;
  }

  // returns `null` if there is no such group, and `dofail` is `true`
  inout(Group) groupById(bool dofail=true) (uint agid) inout nothrow @nogc {
    foreach (const Group g; groups) if (g.gid == agid) return cast(typeof(return))g;
    static if (dofail) assert(0, "group not found"); else return null;
  }

public:
  static Account CreateNew (string aBaseDir, string aAccName) {
    import std.file : mkdirRecurse;
    if (aBaseDir.length == 0 || aBaseDir == "." || aBaseDir == "./") {
      aBaseDir = "./";
    } else if (aBaseDir == "/") {
      assert(0, "wtf?!");
    } else {
      mkdirRecurse(aBaseDir);
      if (aBaseDir[$-1] != '/') aBaseDir ~= '/';
    }
    mkdirRecurse(aBaseDir~"/contacts");
    // write protocol options
    {
      ProtoOptions popt;
      popt.txtser(VFile(aBaseDir~"proto.rc", "w"), skipstname:true);
    }
    // account options
    {
      AccountConfig acc;
      acc.nick = aAccName;
      acc.showPopup = true;
      acc.blinkActivity = true;
      acc.hideEmptyGroups = false;
      acc.ftranAllowed = true;
      acc.resendRotDays = 4;
      acc.hmcOnOpen = 10;
      acc.txtser(VFile(aBaseDir~"config.rc", "w"), skipstname:true);
    }
    // create default group
    {
      GroupOptions[1] grp;
      grp[0].gid = 0;
      grp[0].name = "default";
      grp[0].opened = true;
      //grp[0].hideIfNoVisible = TriOption.Yes;
      grp[].txtser(VFile(aBaseDir~"contacts/groups.rc", "w"), skipstname:true);
    }
    // now load it
    return new Account(aBaseDir);
  }
}


// ////////////////////////////////////////////////////////////////////////// //
class ListItemBase {
private:
  this () {}

protected:
  bool mVisible = true;

public:
  void setupFont () => nvg.fontFace = "ui"; // setup font face for this item
  @property int height () => cast(int)nvg.textFontHeight;
  @property bool visible () => mVisible;
  bool onMouse (MouseEvent event) => false; // true: eaten
  bool onKey (KeyEvent event) => false; // true: eaten
  void drawAt (int x0, int y0, int wdt) {} // real rect is scissored
}


class ListItemAccount : ListItemBase {
public:
  Account acc;

public:
  this (Account aAcc) { assert(aAcc !is null); acc = aAcc; }

  override void setupFont () => nvg.fontFace = "uib"; // bold

  override void drawAt (int x0, int y0, int wdt) {
    int hgt = height;

    nvg.newPath();
    nvg.rect(x0+0.5f, y0+0.5f, wdt, hgt);
    nvg.fillColor(NVGColor("#5fff"));
    nvg.fill();

    nvg.fillColor(NVGColor("#fff"));
    nvg.textAlign = NVGTextAlign.V.Baseline;
    nvg.textAlign = NVGTextAlign.H.Center;
    nvg.text(x0+wdt/2, y0+cast(int)nvg.textFontAscender, acc.info.nick);
  }
}


class ListItemGroup : ListItemBase {
public:
  Group group;

public:
  this (Group aGroup) { assert(aGroup !is null); group = aGroup; }

  override @property bool visible () => group.visible;

  override void drawAt (int x0, int y0, int wdt) {
    int hgt = height;

    nvg.newPath();
    nvg.rect(x0+0.5f, y0+0.5f, wdt, hgt);
    nvg.fillColor(NVGColor("#5888"));
    nvg.fill();

    nvg.fillColor(NVGColor("#ff0"));
    nvg.textAlign = NVGTextAlign.V.Baseline;
    nvg.textAlign = NVGTextAlign.H.Center;
    nvg.text(x0+wdt/2, y0+cast(int)nvg.textFontAscender, group.name);
  }
}


class ListItemContact : ListItemBase {
public:
  Contact ct;

public:
  this (Contact aCt) { assert(aCt !is null); ct = aCt; }

  override @property bool visible () => ct.visible;

  override @property int height () { import std.algorithm : max; return max(cast(int)nvg.textFontHeight, 16); } //FIXME: 16 is image height

  override void drawAt (int x0, int y0, int wdt) {
    int hgt = height;

    /*
    nvg.newPath();
    nvg.rect(x0+0.5f, y0+0.5f, wdt, hgt);
    nvg.fillColor(NVGColor("#5888"));
    nvg.fill();
    */

    // draw icon
    nvg.newPath();
    int iw, ih;
    nvg.imageSize(statusImgId[ct.status], iw, ih);
    //conwriteln("image: (", iw, "x", ih, ")");
    nvg.rect(x0, y0+(hgt-ih)/2, iw, ih);
    nvg.fillPaint(nvg.imagePattern(x0, y0+(hgt-ih)/2, iw, ih, 0, statusImgId[ct.status]));
    nvg.fill();

    nvg.fillColor(NVGColor("#f70"));
    nvg.textAlign = NVGTextAlign.V.Baseline;
    nvg.textAlign = NVGTextAlign.H.Left;
    //conwriteln(nvg.textFontDescender);
    nvg.text(x0+4+iw+4, y0+hgt+cast(int)nvg.textFontDescender, ct.displayNick);
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// visible contact list
final class CList {
private:
  int mActiveItem = -1; // active item (may be different from selected with cursor)
  int mTopY;

public:
  ListItemBase[] items;

public:
  this () {}

  void opOpAssign(string op:"~") (ListItemBase li) {
    if (li is null) return;
    items ~= li;
  }

  void buildAccount (Account acc) {
    if (acc is null) return;
    items ~= new ListItemAccount(acc);
    Contact[] css;
    scope(exit) delete css;
    foreach (Group g; acc.groups) {
      items ~= new ListItemGroup(g);
      css.length = 0;
      css.assumeSafeAppend;
      foreach (Contact c; acc.contacts.byValue) if (c.gid == g.gid) css ~= c;
      import std.algorithm : sort;
      css.sort!((a, b) {
        string s0 = a.displayNick;
        string s1 = b.displayNick;
        auto xlen = (s0.length < s1.length ? s0.length : s1.length);
        foreach (immutable idx, char c0; s0[0..xlen]) {
          if (c0 >= 'A' && c0 <= 'Z') c0 += 32; // poor man's tolower()
          char c1 = s1[idx];
          if (c1 >= 'A' && c1 <= 'Z') c1 += 32; // poor man's tolower()
          if (auto d = c0-c1) return (d < 0);
        }
        return (s0.length < s1.length);
      });
      foreach (Contact c; css) items ~= new ListItemContact(c);
    }
  }

  // true: eaten
  bool onMouse (MouseEvent event) {
    return false;
  }

  // true: eaten
  bool onKey (KeyEvent event) {
    return false;
  }

  // real rect is scissored
  void drawAt (int x0, int y0, int wdt, int hgt) {
    nvg.save();
    scope(exit) nvg.restore();
    //nvg.fontFace = "ui";
    nvg.fontSize = 20;
    nvg.fontBlur = 0;
    nvg.textAlign = NVGTextAlign.H.Left;
    nvg.textAlign = NVGTextAlign.V.Baseline;
    int y = 0;
    foreach (immutable iidx, ListItemBase li; items) {
      if (iidx != mActiveItem && !li.visible) continue;
      li.setupFont();
      int lh = li.height;
      if (lh < 1) continue;
      nvg.save();
      scope(exit) nvg.restore();
      version(all) {
        nvg.intersectScissor(x0, y0+y, wdt, lh);
        li.drawAt(x0, y0+y, wdt);
      } else {
        nvg.translate(x0+0.5f, y0+y+0.5f);
        nvg.intersectScissor(0, 0, wdt, lh);
        li.drawAt(0, 0, wdt);
      }
      y += lh;
      if (y >= hgt) break;
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
__gshared CList clist;


// ////////////////////////////////////////////////////////////////////////// //
void main (string[] args) {
  if (!TOX_VERSION_IS_ABI_COMPATIBLE()) assert(0, "invalid ToxCore library version");

  Account acc;
  try {
    acc = new Account("_fakeacc");
  } catch (Exception e) {
    conwriteln("creating account...");
    acc = Account.CreateNew("_fakeacc", "ketmar");
  }
  // create fake contact
  if (acc.contacts.length == 0) {
    conwriteln("creating fake contact...");
    auto c = acc.createEmptyContact();
    c.info.nick = "test contact";
    c.info.pubkey[] = 0x55;
    c.save();
  }

  //conwriteln("account '", acc.info.nick, "' loaded, ", acc.contacts.length, " contacts, ", acc.groups.length, " groups");

  glconShowKey = "M-Grave";
  glconSetAndSealFPS(0); // draw-on-demand

  conProcessQueue(256*1024); // load config
  conProcessArgs!true(args);
  conProcessQueue(256*1024);

  //setOpenGLContextVersion(3, 2); // up to GLSL 150
  setOpenGLContextVersion(2, 0); // it's enough

  // first time setup
  oglSetupDG = delegate () {
    if (glconCtlWindow.width > 1 && optCListWidth < 0) optCListWidth = glconCtlWindow.width/5;

    glconCtlWindow.vsync = false;

    nvg = createGL2NVG(NVG_ANTIALIAS|NVG_STENCIL_STROKES);
    if (nvg is null) assert(0, "cannot initialize NanoVG");
    loadFonts(nvg);

    loadFmtFonts();

    try {
      static immutable skullsPng = /*cast(immutable(ubyte)[])*/import("data/skulls.png");
      //nvgSkullsImg = nvg.createImage("skulls.png", NVGImageFlags.NoFiltering|NVGImageFlags.RepeatX|NVGImageFlags.RepeatY);
      auto xi = loadImageFromMemory(skullsPng[]);
      scope(exit) delete xi;
      nvgSkullsImg = nvg.createImageFromMemoryImage(xi, NVGImageFlags.NoFiltering|NVGImageFlags.RepeatX|NVGImageFlags.RepeatY);
      if (nvgSkullsImg == 0) assert(0, "cannot load background image");
    } catch (Exception e) {
      assert(0, "cannot load background image");
    }
    buildStatusImages();

    layFixFontDG = delegate (ref LayFontStyle st) nothrow @trusted @nogc {
      //{ import core.stdc.stdio; printf("monospace=%d; italic=%d; bold=%d\n", (st.monospace ? 1 : 0), (st.italic ? 1 : 0), (st.bold ? 1 : 0)); }
      char[12] tbuf;
      int tbufpos = 0;
      void put (const(char)[] s...) nothrow @trusted @nogc {
        if (s.length == 0) return;
        if (tbuf.length-tbufpos < s.length) assert(0, "wtf?!");
        tbuf.ptr[tbufpos..tbufpos+s.length] = s[];
        tbufpos += cast(int)s.length;
      }
      put(st.monospace ? "mono" : "text");
      if (st.italic) put("i");
      if (st.bold) put("b");
      st.fontface = laf.fontFaceId(tbuf[0..tbufpos]);
    };

    lay = new LayTextClass(laf, glconCtlWindow.width/2);
    lay.fontStyle.fontsize = 16;
    lay.fontStyle.color = NVGColor.darkorange.asUint;
    lay.fontStyle.monospace = true;
    lay.fontStyle.bgcolor = NVGColor("#222").asUint;
    lay.put("ketmar (бля)");
    lay.fontStyle.monospace = false;
    lay.putHardSpace(64);
    lay.putExpander();
    lay.put("!");
    lay.putExpander();
    lay.put("2018/02/12");
    lay.putNBSP();
    lay.fontStyle.color = NVGColor("#fff").asUint;
    lay.fontStyle.bgcolor = NVGColor("#006").asUint;
    lay.put("11:09:03");
    lay.endPara();
    lay.fontStyle.bgcolor = NVGColor.transparent.asUint;
    lay.fontStyle.color = NVGColor.darkorange.asUint;
    lay.fontStyle.fontsize = 20;
    lay.put("this is my text, lol (еб\u00adёна КОЧЕРГА!)");
    lay.endPara();
    lay.finalize();
    //conwriteln("wdt=", lay.width, "; text width=", lay.textWidth);
    lastWindowWidth = glconCtlWindow.width;

    clist = new CList();
    clist.buildAccount(acc);

    glconCtlWindow.setMinSize(640, 480);
  };

  resizeEventDG = delegate (int wdt, int hgt) {
    //conwriteln("old=", lastWindowWidth, "; new=", wdt);
    if (wdt > 1 && optCListWidth > 0 && lastWindowWidth > 0 && lastWindowWidth != wdt) {
      immutable double frc = lastWindowWidth/optCListWidth;
      optCListWidth = cast(int)(wdt/frc);
      if (optCListWidth < 64) optCListWidth = 64;
      lastWindowWidth = wdt;
    }
    lay.relayout(wdt);
  };

  keyEventDG = delegate (KeyEvent event) {
    //if (event.pressed && event == "*-Q") { concmd("quit"); return; }
    if (event == "U-*-Q") { concmd("quit"); return; }
    if (clist !is null && clist.onKey(event)) return;
    if (event == "D-Space") {
      // add random text
      lay.fontStyle.fontsize = 16;
      lay.fontStyle.color = NVGColor.k8orange.asUint;
      lay.fontStyle.monospace = true;
      lay.fontStyle.bgcolor = NVGColor("#222").asUint;
      lay.put("ketmar");
      lay.fontStyle.monospace = false;
      lay.putHardSpace(64);
      lay.putExpander();
      lay.put("!");
      lay.putExpander();
      lay.put("2018/02/12");
      lay.putNBSP();
      lay.fontStyle.color = NVGColor("#fff").asUint;
      lay.fontStyle.bgcolor = NVGColor("#006").asUint;
      lay.put("11:09:03");
      lay.endPara();
      lay.fontStyle.bgcolor = NVGColor.transparent.asUint;
      lay.fontStyle.color = NVGColor.k8orange.asUint;
      lay.fontStyle.fontsize = 20;
      import std.random;
      // words
      version(none) {
        foreach (immutable widx; 0..uniform!"[]"(2, 28)) {
          // one word
          if (widx != 0) lay.put(" ");
          foreach (; 0..uniform!"[]"(1, 9)) {
            char ch = cast(char)('a'+uniform!"[]"(0, 25));
            lay.put(ch);
            //lay.putSoftHypen();
          }
        }
      } else {
        // long word, for hyphenation test
        foreach (immutable idx; 0..228) {
          char ch = cast(char)('a'+uniform!"[]"(0, 25));
          lay.put(ch);
          if (idx%24 == 23) lay.putSoftHypen();
        }
      }
      lay.endPara();
      lay.finalize();
      // redraw
      glconResetNextFrame();
      return;
    }
  };

  mouseEventDG = delegate (MouseEvent event) {
    if (clist !is null && clist.onMouse(event)) return;
  };

  charEventDG = delegate (dchar ch) {
  };

  focusEventDG = delegate (bool focused) {
  };

  // draw main screen
  redrawFrameDG = delegate () {
    if (nvg is null) return;

    //oglSetup2D(glconCtlWindow.width, glconCtlWindow.height);
    glViewport(0, 0, glconCtlWindow.width, glconCtlWindow.height);
    glMatrixMode(GL_MODELVIEW);
    //conwriteln(glconCtlWindow.width, "x", glconCtlWindow.height);

    glClearColor(0, 0, 0, 0);
    glClear(glNVGClearFlags/*|GL_COLOR_BUFFER_BIT*/);

    {
      nvg.beginFrame(glconCtlWindow.width, glconCtlWindow.height);
      scope(exit) nvg.endFrame();

      if (clist !is null && optCListWidth > 0) {
        // draw contact list
        int cx = 1;
        int cy = 1;
        int wdt = optCListWidth;
        int hgt = nvg.height-cy*2;

        nvg.shapeAntiAlias = true;
        nvg.nonZeroFill;
        nvg.strokeWidth = 1;

        {
          nvg.save();
          scope(exit) nvg.restore();

          nvg.newPath();
          nvg.roundedRect(cx+0.5f, cy+0.5f, wdt, hgt, 6);
          {
            int w, h;
            nvg.imageSize(nvgSkullsImg, w, h);
            nvg.fillPaint(nvg.imagePattern(0, 0, w, h, 0, nvgSkullsImg));
          }
          nvg.strokeColor(NVGColor("#f70"));
          nvg.fill();
          nvg.stroke();

          nvg.intersectScissor(cx+3.5f, cy+3.5f, wdt-3*2, hgt-3*2);

          clist.drawAt(cx+3, cy+3, wdt-3*2, hgt-3*2);
        }

        {
          nvg.save();
          scope(exit) nvg.restore();

          // draw chat log
          cx += wdt+2;
          wdt = nvg.width-cx-1;
          nvg.newPath();
          nvg.roundedRect(cx+0.5f, cy+0.5f, wdt, hgt, 6);
          nvg.fillColor(NVGColor.black);
          nvg.strokeColor(NVGColor("#f70"));
          nvg.fill();
          nvg.stroke();

          nvg.intersectScissor(cx+3.5f, cy+3.5f, wdt-3*2, hgt-3*2);
          lay.relayout(wdt-3*2); // this is harmess if width wasn't changed
          nvg.drawLayouter(lay, 0, cx+3, cy+3, hgt);
        }
      }
    }
  };

  glconRunGLWindowResizeable(800, 600, "BioAcid", "BIOACID");
}