#include "app.h"

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

  LOGDBG("graph: init");

  const uint16_t F = 65535; // full

  const uint16_t H = 32768; // half

  const uint16_t Q = 16384; // quart

  const uint16_t colorsRgb[GS_COUNT*2][3] = { // background, foreground

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

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

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

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

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

  // create palette

  g->app = app;

  g->cm = xcb_generate_id(g->app->xcb);

  xcb_create_colormap(g->app->xcb, XCB_COLORMAP_ALLOC_NONE, g->cm, g->app->win, g->app->screen->root_visual);

  // encqueue colors allocarion requests

  xcb_alloc_color_cookie_t cookies[GS_COUNT*2];

  for(int i = 0; i < GS_COUNT*2; ++i)

    cookies[i] = xcb_alloc_color(g->app->xcb, g->cm, colorsRgb[i][0], colorsRgb[i][1], colorsRgb[i][2]);

  // take color allocation replies (take color indices)

  uint32_t colors[GS_COUNT*2];

  for(int i = 0; i < GS_COUNT*2; ++i) {

    xcb_alloc_color_reply_t *reply = xcb_alloc_color_reply(g->app->xcb, cookies[i], NULL);

    colors[i] = reply->pixel;

    free(reply);

  }

  // associate palette with the window

  xcb_change_window_attributes(g->app->xcb, g->app->win, XCB_CW_COLORMAP, &g->cm);

  char fontname[1024] = "fixed";

  { // scan fonts

    int found = 0;

    int maxcnt = 1024;

    const char *pattern = "*misc*medium-r-normal*-c-0-ISO10646-1*";

    LOGDBG("graph: init: scan fonts by pattern [%s], maxcnt=%d", pattern, maxcnt);

    xcb_list_fonts_cookie_t c = xcb_list_fonts(g->app->xcb, maxcnt, strlen(pattern), pattern);

    xcb_list_fonts_reply_t *r = xcb_list_fonts_reply(g->app->xcb, c, NULL);

    if (r) {

      int cnt = xcb_list_fonts_names_length(r);

      LOGDBG("graph: init: found %d fonts", cnt);

      xcb_str_iterator_t it = xcb_list_fonts_names_iterator(r);

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

        int l = xcb_str_name_length(it.data);

        if (!found && l < sizeof(fontname)) {

          memcpy(fontname, xcb_str_name(it.data), l);

          fontname[l] = 0;

          found = 1;

        }

        #ifndef NDEBUG

        char buf[1024] = {};

        if (l > 1023) l = 1023;

        memcpy(buf, xcb_str_name(it.data), l);

        buf[l] = 0;

        LOGDBG("graph: init: found font: %s", buf);

        #endif

        xcb_str_next(&it);

      }

      free(r);

    } else {

      LOGWRN("graph: init: cannot list fonts");

    }

  }

  // init font

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

  g->font = xcb_generate_id(g->app->xcb);

  xcb_void_cookie_t c = xcb_open_font_checked(g->app->xcb, g->font, strlen(fontname), fontname);

  if (xcb_request_check(g->app->xcb, c)) {

    LOGERR("graph: init: cannot open font [%s]", fontname);

    xcb_change_window_attributes(g->app->xcb, g->app->win, XCB_CW_COLORMAP, &g->app->screen->default_colormap);

    xcb_free_colormap(g->app->xcb, g->cm);

    return 0;

  }

  // create contexts

  uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT | XCB_GC_GRAPHICS_EXPOSURES;

  uint32_t values[4] = {0, 0, g->font, 0};

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

    values[0] = colors[i*2 + 1]; // foreground

    values[1] = colors[i*2];     // background

    g->gc[i] = xcb_generate_id(g->app->xcb);

    xcb_create_gc(g->app->xcb, g->gc[i], g->app->win, mask, values);

  }

  return 1;

}

void graphDeinit(Graph *g) {

  LOGDBG("graph: deinit");

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

    xcb_free_gc(g->app->xcb, g->gc[i]);

  xcb_close_font(g->app->xcb, g->font);

  xcb_change_window_attributes(g->app->xcb, g->app->win, XCB_CW_COLORMAP, &g->app->screen->default_colormap);

  xcb_free_colormap(g->app->xcb, g->cm);

}

void graphResize(Graph *g)

  { }

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

  xcb_rectangle_t r = {x, y, w, h};

  xcb_poly_fill_rectangle(g->app->xcb, g->app->win, g->gc[GS_WINDOW], 1, &r);

}

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

  GraphStyle s = active ? GS_BUTTON_ACTIVE : GS_BUTTON_INACTIVE;

  xcb_rectangle_t r = {x, y, w, h};

  xcb_poly_fill_rectangle(g->app->xcb, g->app->win, g->gc[s], 1, &r);

}

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

  tl->g = g;

  tl->x = tl->y = 0;

  tl->len = 0;

  // convert utf8 to char2b

  const unsigned char *s = (const unsigned char *)text;

  while(*s && tl->len < TL_MAXLEN) {

    unsigned int d = 0xfffd;

    if (!(s[0] & 0x80)) {

      d = s[0];

    } else

    if ( (s[0] & 0xe0) == 0xc0

      && (s[1] & 0xc0) == 0x80 )

    {

      d = ((s[0] & 0x1f) << 6)

        | ((s[1] & 0x3f) << 0);

      ++s;

    } else

    if ( (s[0] & 0xf0) == 0xe0

      && (s[1] & 0xc0) == 0x80

      && (s[2] & 0xc0) == 0x80 )

    {

      d = ((s[0] & 0x0f) << 12)

        | ((s[1] & 0x3f) <<  6)

        | ((s[2] & 0x3f) <<  0);

      s += 2;

    }

    tl->text[tl->len].byte1 = d >> 8;

    tl->text[tl->len].byte2 = d & 0xff;

    ++tl->len;

    ++s;

  }

  if (!tl->len)

    return;

  // measure text

  xcb_query_text_extents_cookie_t cookie =

    xcb_query_text_extents(tl->g->app->xcb, tl->g->font, tl->len, tl->text);

  xcb_query_text_extents_reply_t *tx = xcb_query_text_extents_reply(tl->g->app->xcb, cookie, NULL);

  if (!tx) {

    LOGWRN("text layout: cannot get text extents for string [%s] len=%d", text, tl->len);

    //tl->len = 0;

    return;

  }

  tl->x = -tx->overall_left - tx->overall_width/2;

  tl->y = tx->font_ascent/2;

  free(tx);

}

void textLayoutDeinit(TextLayout *tl)

  { }

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

  if (!tl->len) return;

  GraphStyle s = active ? GS_TEXT_ACTIVE : GS_TEXT_INACTIVE;

  xcb_image_text_16(tl->g->app->xcb, tl->len, tl->g->app->win, tl->g->gc[s], x + tl->x, y + tl->y, tl->text);

}