#include "app.h"

int graphInit(Graph *g, App *app) {

  LOGDBG("graph: init");

  CLEARFROM(g, app);

  g->app = app;

  enum {

    F = 65535u,   // full

    H = 32768u,   // half

    Q = 16384u }; // quart

  static const XRenderColor renderColors[GC_COUNT] = {

    { 0, 0, Q, F },   // window

    { 0, 0, H, F },   // inactive button

    { 0, 0, F, F },   // active button

    { H, 0, F, F },   // active button 2

    { F, F, 0, F },   // inactive text

    { F, F, 0, F },   // active text

    { F, F, 0, F } }; // active text 2

  static const char *fonts[] = FONTS;

  static const int sizes[FONT_MAX_SIZES] = FONT_SIZES;

  LOGDBG("graph: init: create XftDraw");

  g->draw = XftDrawCreate(

    g->app->dpy,

    g->app->win,

    DefaultVisual(g->app->dpy, g->app->screen),

    DefaultColormap(g->app->dpy, g->app->screen) );

  if (!g->draw)

    return LOGERR("graph: init: cannot create XftDraw");

  LOGDBG("graph: init: open fonts");

  char buf[1024] = {};

  for(int i = 0; i < FONT_MAX_SIZES; ++i) {

    if (!sizes[i]) break;

    for(int j = 0; j < COUNTOF(fonts); ++j) {

      snprintf(buf, sizeof(buf), "%s:size=%d", fonts[j], sizes[i]);

      LOGDBG("graph: init: try open font [%s]", buf);

      g->fonts[g->fontsCnt] = XftFontOpenName(g->app->dpy, g->app->screen, buf);

      if (g->fonts[g->fontsCnt]) {

        ++g->fontsCnt;

        break;

      } else {

        LOGDBG("graph: init: cannot open font [%s]", buf);

      }

    }

  }

  if (!g->fontsCnt) {

    LOGERR("graph: init: cannot open any font");

    XftDrawDestroy(g->draw);

    CLEARFROM(g, app);

    return 0;

  }

  LOGDBG("graph: init: allocate colors");

  for(int i = 0; i < GC_COUNT; ++i) {

    XftColorAllocValue(

      g->app->dpy,

      DefaultVisual(g->app->dpy, g->app->screen),

      DefaultColormap(g->app->dpy, g->app->screen),

      &renderColors[i],

      &g->colors[i] );

  }

  return 1;

}

void graphDeinit(Graph *g) {

  LOGDBG("graph: deinit");

  for(int i = 0; i < GC_COUNT; ++i)

    XftColorFree(

      g->app->dpy,

      DefaultVisual(g->app->dpy, g->app->screen),

      DefaultColormap(g->app->dpy, g->app->screen),

      &g->colors[i] );

  for(int i = 0; i < g->fontsCnt; ++i)

    XftFontClose(g->app->dpy, g->fonts[i]);

  XftDrawDestroy(g->draw);

}

void graphResize(Graph *g)

  { }

void graphDrawBackgound(Graph *g, int x, int y, int w, int h) {

  XftDrawRect(g->draw, &g->colors[GC_WINDOW], x, y, w, h);

}

void graphDrawButton(Graph *g, int x, int y, int w, int h, int active) {

  GraphStyle s = active == 1 ? GC_BUTTON_ACTIVE

               : active == 2 ? GC_BUTTON_ACTIVE2

               :               GC_BUTTON_INACTIVE;

  XftDrawRect(g->draw, &g->colors[s], x, y, w, h);

}

void textLayoutInit(TextLayout *tl, Graph *g, const char *text) {

  CLEARFROM(tl, g);

  tl->g = g;

  tl->len = text ? strlen(text) : 0;

  tl->text = text;

  if (!tl->len)

    return;

  for(int i = 0; i < tl->g->fontsCnt; ++i) {

    XGlyphInfo e = {};

    XftTextExtentsUtf8(g->app->dpy, g->fonts[i], (const FcChar8*)tl->text, tl->len, &e);

    int w = e.width;

    int h = tl->g->fonts[i]->ascent;

    int minw = h + h/3;

    tl->sizes[i].x = -e.x - w/2;

    tl->sizes[i].y = h/2;

    tl->sizes[i].w = w < minw ? minw : w;

    tl->sizes[i].h = h;

  }

}

void textLayoutDeinit(TextLayout *tl)

  { CLEARFROM(tl, g); }

void textLayoutDraw(TextLayout *tl, int x, int y, int w, int h, int active) {

  if (!tl->len) return;

  GraphStyle s = active == 1 ? GC_TEXT_ACTIVE

               : active == 2 ? GC_TEXT_ACTIVE2

               :               GC_TEXT_INACTIVE;

  // find font size

  int i;

  for(i = tl->g->fontsCnt - 1; i > 0; --i)

    if (tl->sizes[i].w <= w && tl->sizes[i].h <= h) break;

  XftDrawStringUtf8(

    tl->g->draw,

    &tl->g->colors[s],

    tl->g->fonts[i],

    x + tl->sizes[i].x,

    y + tl->sizes[i].y,

    (const FcChar8*)tl->text,

    tl->len );

}