#include "app.h"

#include <math.h></math.h>

#include <sys time.h=""></sys>

#include <sys types.h=""></sys>

#include <poll.h></poll.h>

#include <unistd.h></unistd.h>

#include <x11 xutil.h=""></x11>

#include <x11 xatom.h=""></x11>

int appInit(App *app, const char *touch_dev) {

  LOGDBG("app: init");

  CLEARFROM(app, dpy);

  LOGDBG("app: init: connect to xcb");

  app->dpy = XOpenDisplay(NULL);

  if (!app->dpy)

    return LOGERR("app: init: cannot connect to xcb");

  LOGDBG("app: init: get screen");

  app->screen = DefaultScreen(app->dpy);

  app->sw = DisplayWidth(app->dpy, app->screen);

  app->sh = DisplayHeight(app->dpy, app->screen);

  XRRRotations(app->dpy, app->screen, &app->sr);

  LOGDBG("app: init: screen=%d sw=%d sh=%d sr=%02x", app->screen, app->sw, app->sh, app->sr);

  LOGDBG("app: init: get root window");

  app->root = RootWindow(app->dpy, app->screen);

  LOGDBG("app: init: create window");

  app->x = 0;

  app->w = app->sw * WIDTH_SCALE;

  app->h = app->sh * HEIGHT_SCALE;

  #if defined(WIDTH_SCALE_P) && defined(HEIGHT_SCALE_P)

  if (app->sw < app->sh) {

    app->w = app->sw * WIDTH_SCALE_P;

    app->h = app->sh * HEIGHT_SCALE_P;

  }

  #endif

  #ifdef TOP

  app->y = 0;

  #else

  app->y = app->sh - app->h;

  #endif

  XSetWindowAttributes attr = {};

  #ifdef NOBORDER

  attr.override_redirect = 1;

  #endif

  app->win = XCreateWindow(

    app->dpy, app->root,               // display and parent window

    app->x, app->y, app->w, app->h, 0, // position, size and border width

    CopyFromParent, CopyFromParent, CopyFromParent, // depth, class and visual

    CWOverrideRedirect, &attr );        // mask with attributes

  XSelectInput(

    app->dpy, app->win,

      StructureNotifyMask

    | ExposureMask

    | ButtonPressMask

    | ButtonReleaseMask

    | Button1MotionMask );

  #if defined(NOBORDER) || defined(DOCK)

  LOGDBG("app: init: disable decorations");

  Atom amh = XInternAtom(app->dpy, "_MOTIF_WM_HINTS", False);

  long amhv[5] = { 2 };

  XChangeProperty(app->dpy, app->win, amh, amh, 32, PropModeReplace, (unsigned char*)amhv, 5);

  #endif

  #ifndef NOBORDER

  LOGDBG("app: init: set window title");

  char *title = TITLE;

  XTextProperty wtitle;

  if (!XStringListToTextProperty(&title, 1, &wtitle)) {

    LOGWRN("app: init: XStringListToTextProperty error for title: %s", title);

  } else {

    XSetWMName(app->dpy, app->win, &wtitle);

    XFree(wtitle.value);

  }

  #endif

  #ifdef DOCK

  LOGDBG("app: init: set window as dock");

  Atom awt = XInternAtom(app->dpy, "_NET_WM_WINDOW_TYPE", False);

  Atom awtv = XInternAtom(app->dpy, "_NET_WM_WINDOW_TYPE_TOOLBAR", False);

  XChangeProperty(app->dpy, app->win, awt, XA_ATOM, 32, PropModeReplace, (unsigned char*)&awtv, 1);

  Atom aaa = XInternAtom(app->dpy, "_NET_WM_ALLOWED_ACTIONS", False);

  XChangeProperty(app->dpy, app->win, aaa, XA_ATOM, 32, PropModeReplace, NULL, 0);

  #endif

  Atom ahps = XInternAtom(app->dpy, "_HILDON_PORTRAIT_MODE_SUPPORT", True);

  if (ahps) {

    LOGDBG("app: init: set portrait mode support for hildon");

    long v = 1;

    XChangeProperty(app->dpy, app->win, ahps, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)&v, 1);

  }

  LOGDBG("app: init: set window minimum size");

  XSizeHints *wsh = XAllocSizeHints();

  if (!wsh) {

    LOGWRN("app: init: XAllocSizeHints error");

  } else {

    #ifdef LOCK_SIZE

    wsh->flags      = PMinSize | PMaxSize;

    wsh->min_width  = wsh->max_width  = app->w;

    wsh->min_height = wsh->max_height = app->h;

    #else

    wsh->flags      = PMinSize;

    wsh->min_width  = MIN_WIDTH;

    wsh->min_height = MIN_HEIGHT;

    #endif

    XSetSizeHints(app->dpy, app->win, wsh, XA_WM_NORMAL_HINTS);

    XFree(wsh);

  }

  // window must not grab the focus

  LOGDBG("app: init: set window input hint");

  XWMHints *wmh = XAllocWMHints();

  if (!wmh) {

    LOGWRN("app: init: XAllocWMHints error");

  } else {

    wmh->flags = InputHint;

    wmh->input = False;

    XSetWMHints(app->dpy, app->win, wmh);

    XFree(wmh);

  }

  // subscribe to windows delete message from window manager

  app->aWmDel = XInternAtom(app->dpy, "WM_DELETE_WINDOW", False);

  XSetWMProtocols(app->dpy, app->win, &app->aWmDel, 1);

  // subscribe to keyboard state and layout changes

  XkbSelectEvents(app->dpy, XkbUseCoreKbd, XkbMapNotifyMask | XkbStateNotifyMask, XkbMapNotifyMask | XkbStateNotifyMask);

  #ifdef SCREEN_EVENTS

  // subscribe to xrandr events

  if (!XRRQueryExtension(app->dpy, &app->xrev, &app->xrerr)) {

    LOGWRN("app: init: XRRQueryExtension error");

  } else {

    app->xron = 1;

    XRRSelectInput(app->dpy, app->win, RRScreenChangeNotifyMask);

  }

  #endif

  //appMove(app, app->x, app->y, app->w, app->h, 1);

  //appUpdateStrut(app);

  // init submodules

  touchInit(&app->touch, app, touch_dev); // touch is optional

  if (graphInit(&app->graph, app)) {

    graphResize(&app->graph);

    if (inputInit(&app->input, app)) {

      if (keyboardInit(&app->keyboard, app)) {

        return 1;

      }

      inputDeinit(&app->input);

    }

    graphDeinit(&app->graph);

  } else {

    XCloseDisplay(app->dpy);

  }

  return 0;

}

void appDeinit(App *app) {

  LOGDBG("app: deinit");

  keyboardDeinit(&app->keyboard);

  inputDeinit(&app->input);

  graphDeinit(&app->graph);

  XCloseDisplay(app->dpy);

}

int appRun(App *app) {

  LOGDBG("app: run");

  if (app->run)

    return LOGERR("app: run: seems already run");

  app->run = 1;

  LOGDBG("app: run: show window");

  XMapWindow(app->dpy, app->win);

  appUpdateStrut(app);

  appMove(app, app->x, app->y, app->w, app->h, 1);

  LOGDBG("app: run: get connection file descriptor");

  int fd = ConnectionNumber(app->dpy);

  if (fd < 0)

    LOGERR("app: run: cannot get XLib file descruptor");

  LOGDBG("app: run: event loop");

  int buttonDown = 0;

  unsigned int buttonDownMs = 0;

  struct pollfd fds[2] = {};

  fds[0].fd = fd;

  fds[1].fd = app->touch.fd;

  fds[0].events = fds[1].events = POLLIN;

  int fdcnt = app->touch.app ? 2 : 1;

  XFlush(app->dpy);

  while(1) {

    int hasEvent = 0;

    XEvent event = {};

    fds[0].revents = fds[1].revents = 0;

    // wait for next event

    if (XPending(app->dpy)) {

      XNextEvent(app->dpy, &event);

      hasEvent = 1;

    } else

    if (buttonDown != 1) {

      // just wait for fds

      poll(fds, fdcnt, -1);

    } else {

      // manually call select for the X-socket to use timeout

      int dt = monotonicMs() - buttonDownMs;

      if (dt < LONGPRESS_MS) {

        dt = LONGPRESS_MS - dt;

        LOGDBG("app: run: use poll with timeout %d ms", dt);

        XFlush(app->dpy);

        poll(fds, fdcnt, dt);

      }

    }

    if (!hasEvent && fds[0].revents && XPending(app->dpy)) {

      XNextEvent(app->dpy, &event);

      hasEvent = 1;

    }

    if (hasEvent) {

      // handle X11 events

      switch(event.type) {

      case Expose: {

        LOGDBG( "app: expose: x=%d, y=%d, w=%d, h=%d",

                event.xexpose.x, event.xexpose.y, event.xexpose.width, event.xexpose.height );

        appInvalidateRect(app, event.xexpose.x, event.xexpose.y, event.xexpose.width, event.xexpose.height);

        break;

      }

      case ConfigureNotify: {

        if ( event.xconfigure.width

          && event.xconfigure.height

          && ( app->x != event.xconfigure.x

            || app->y != event.xconfigure.y

            || app->w != event.xconfigure.width

            || app->h != event.xconfigure.height ))

        {

          LOGDBG( "app: moved: x=%d y=%d w=%d, h=%d",

                  event.xconfigure.x, event.xconfigure.y, event.xconfigure.width, event.xconfigure.height );

          int resized = app->w != event.xconfigure.width || app->h != event.xconfigure.height;

          app->x = event.xconfigure.x;

          app->y = event.xconfigure.y;

          app->w = event.xconfigure.width;

          app->h = event.xconfigure.height;

          if (resized) graphResize(&app->graph);

          appUpdateStrut(app);

        }

        break;

      }

      case ButtonPress: {

        if (event.xbutton.button == 1) {

          LOGDBG("app: mouse down: x=%d, y=%d", event.xbutton.x, event.xbutton.y);

          if (!buttonDown) { buttonDown = 1; buttonDownMs = monotonicMs(); }

          keyboardMouseDown(&app->keyboard, event.xbutton.x, event.xbutton.y);

        }

        appUpdateStrut(app);

        break;

      }

      case ButtonRelease: {

        if (event.xbutton.button == 1) {

          LOGDBG("app: mouse up");

          buttonDown = 0;

          keyboardMouseUp(&app->keyboard);

        }

        break;

      }

      case MotionNotify: {

        if (event.xmotion.state & Button1Mask) {

          LOGDBG("app: mouse motion: x=%d, y=%d", event.xmotion.x, event.xmotion.y);

          keyboardMouseMotion(&app->keyboard, event.xmotion.x, event.xmotion.y);

        }

        break;

      }

      case MappingNotify: {

        if ( event.xmapping.request == MappingModifier

          || event.xmapping.request == MappingKeyboard )

        {

          LOGDBG("app: kayboard layout changed");

          XRefreshKeyboardMapping(&event.xmapping);

          inputUpdateLayout(

            &app->input,

            event.xmapping.first_keycode,

            event.xmapping.first_keycode + event.xmapping.count );

        }

        break;

      }

      case ClientMessage: {

        if (event.xclient.data.l[0] == app->aWmDel) {

          LOGDBG("app: delete window event");

          appStop(app, 0);

        }

        break;

      }

      default:

        if (app->xron && event.type == app->xrev + RRScreenChangeNotify) {

          LOGDBG("app: screen change event");

          XRRScreenChangeNotifyEvent *ev = (XRRScreenChangeNotifyEvent*)&event;

          appUpdateScreenSize(app, ev->width, ev->height, ev->rotation);

        }

        break;

      }

    }

    if (app->touch.app && fds[1].revents) {

      // handle direct touch events

      int x, y, p;

      while(touchGet(&app->touch, &x, &y, &p)) {

        if (p && !buttonDown) {

          LOGDBG("app: touch pressed: x=%d, y=%d", x, y);

          buttonDown = 1; buttonDownMs = monotonicMs();

          keyboardMouseDown(&app->keyboard, x, y);

          hasEvent = 1;

        } else

        if (!p && buttonDown) {

          LOGDBG("app: touch released");

          buttonDown = 0;

          keyboardMouseUp(&app->keyboard);

          hasEvent = 1;

        } else

        if (p) {

          LOGDBG("app: touch motion: x=%d, y=%d", x, y);

          keyboardMouseMotion(&app->keyboard, x, y);

          hasEvent = 1;

        }

      }

    }

    if (buttonDown == 1 && monotonicMs() - buttonDownMs >= LONGPRESS_MS) {

        LOGDBG("app: long press");

        buttonDown = 2;

        keyboardMouseLongDown(&app->keyboard);

        hasEvent = 1;

    }

    if (app->run != 1) break;

    if (!hasEvent) continue;

    inputUpdateModifiers(&app->input);

    keyboardResize(&app->keyboard);

    keyboardUpdateModifiers(&app->keyboard);

    if (app->irw > 0 && app->irh > 0) {

      LOGDBG("app: draw: x=%d, y=%d, w=%d, h=%d", app->irx, app->iry, app->irw, app->irh);

      graphDrawBackgound(&app->graph, app->irx, app->iry, app->irw, app->irh);

      keyboardDraw(&app->keyboard, app->irx, app->iry, app->irw, app->irh);

      app->irw = 0;

    }

  }

  int err = app->run == -2;

  app->run = 0;

  LOGDBG("app: run: done err=%d", err);

  return !err;

}

void appStop(App *app, int err) {

  LOGDBG("app: stop: err=%d", err);

  if (!app->run) {

    LOGERR("app: stop: seems not started");

    return;

  }

  if (app->run == 1) app->run = -1;

  if (err) app->run = -2;

}

void appUpdateStrut(App *app) {

  #ifdef DOCK

  long v[12] = { 0, 0, 0, app->h, 0, app->sh, 0, app->sh, 0, app->sw, 0, app->sw };

  #ifdef TOP

  v[2] = app->h;

  #else

  v[3] = app->h;

  #endif

  if (app->dockt == v[2] && app->dockb == v[3])

    return;

  app->dockt = v[2];

  app->dockb = v[3];

  LOGDBG("app: update strut: %lu %lu %lu %lu", v[0], v[1], v[2], v[3]);

  Atom k = XInternAtom(app->dpy, "_NET_WM_STRUT", False);

  XChangeProperty(app->dpy, app->win, k, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)v, 4);

  Atom kp = XInternAtom(app->dpy, "_NET_WM_STRUT_PARTIAL", False);

  XChangeProperty(app->dpy, app->win, kp, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)v, 12);

  #ifdef TOP

  appMove(app, 0, 0, app->sw, app->h, 1);

  #else

  appMove(app, 0, app->sh - app->h, app->sw, app->h, 1);

  #endif

  #endif // DOCK

}

void appUpdateScreenSize(App *app, int sw, int sh, Rotation sr) {

  if (sw <= 0 || sh <= 0) return;

  if (sw == app->sw && sh == app->sh && sr == app->sr) return;

  LOGDBG("app: update screen size: w=%d, h=%d, r=%d", sw, sh, sr);

  app->sr = sr;

  if (sw == app->sw && sh == app->sh) return;

  #if defined(DOCK) || (defined(LOCK_SIZE) && defined(NOBORDER) && defined(NOTITLE))

  // static size case

  int w = sw * WIDTH_SCALE;

  int h = sh * HEIGHT_SCALE;

  #if defined(WIDTH_SCALE_P) && defined(HEIGHT_SCALE_P)

  if (sw < sh) {

    w = sw * WIDTH_SCALE_P;

    h = sh * HEIGHT_SCALE_P;

  }

  #endif

  int x0 = 0;

  #ifdef TOP

  int y0 = 0;

  #else

  int y0 = sh - h;

  #endif

  #else

  // dynamic size case

  double kx = sw/(double)app->sw;

  double ky = sh/(double)app->sh;

  #if defined(WIDTH_SCALE_P) && defined(HEIGHT_SCALE_P)

  // rescale for portrait/landscape switching

  if (app->sw < app->sh && sw >= sh) {

    // portrait -> landscape

    kx *= ((double)WIDTH_SCALE)/((double)WIDTH_SCALE_P);

    ky *= ((double)HEIGHT_SCALE)/((double)HEIGHT_SCALE_P);

  } else

  if (app->sw >= app->sh && sw < sh) {

    // landscape -> portrait

    kx *= ((double)WIDTH_SCALE_P)/((double)WIDTH_SCALE);

    ky *= ((double)HEIGHT_SCALE_P)/((double)HEIGHT_SCALE);

  }

  #endif

  // scale window corners

  int x0 = (int)round( app->x*kx );

  int y0 = (int)round( app->y*ky );

  int x1 = (int)round( (app->x + app->w)*kx );

  int y1 = (int)round( (app->y + app->h)*ky );

  int w = x1 - x0;

  int h = y1 - y0;

  #endif

  app->sw = sw;

  app->sh = sh;

  appMove(app, x0, y0, w, h, 0);

}

void appMove(App *app, int x, int y, int w, int h, int force) {

  if (w < MIN_WIDTH)  w = MIN_WIDTH;

  if (h < MIN_HEIGHT) h = MIN_HEIGHT;

  unsigned int mask = 0;

  XWindowChanges ch = {};

  if (force || app->x != x) ch.x = x, mask |= CWX;

  if (force || app->y != y) ch.y = y, mask |= CWY;

  if (force || app->w != w) ch.width  = w, mask |= CWWidth;

  if (force || app->h != h) ch.height = h, mask |= CWHeight;

  if (!mask) return;

  LOGDBG("app: move: x=%d, y=%d, w=%d, h=%d", x, y, w, h);

  XConfigureWindow(app->dpy, app->win, mask, &ch);

  XFlush(app->dpy);

}

void appInvalidateRect(App *app, int x, int y, int w, int h) {

  LOGDBG("app: invalidate rect: x=%d, y=%d, w=%d, h=%d", x, y, w, h);

  rectIntersect(&x, &y, &w, &h, 0, 0, app->w, app->h);

  rectMerge(&app->irx, &app->iry, &app->irw, &app->irh, x, y, w, h);

  LOGDBG("app: invalidate rect: summary x=%d, y=%d, w=%d, h=%d", app->irx, app->iry, app->irw, app->irh);

}