#include <stdlib.h>
#include <stdio.h>

#include <X11/XKBlib.h>

#include "xkb_util.h"

#include <check.h>

/* 
 * check the result of issuing a GetNames request with Xlib and xcb
 * test for special case: switch that contains variable size fields
 */
START_TEST(check_xkb_get_names_request)
{
  /* Xlib */
  Display *d = XkbOpenDisplay(NULL, 0, 0, 0, 0, 0);
  XkbDescPtr xlib_result, p = XkbGetKeyboard(d, XkbKeycodesNameMask, XkbUseCoreKbd);
  
  /* xcb */
  xcb_connection_t *c = xcb_connect (NULL, NULL);
  xcb_generic_error_t *e = NULL;  
  xcb_xkb_use_extension_reply_t *reply = xcb_xkb_util_query_extension(c, 1, 0, &e);
  xcb_xkb_get_names_reply_t *get_names_reply;
  void *names_buffer, *new_buffer = NULL;
  xcb_xkb_get_names_value_list_t xcb_result, names;
  int l0, l1, l2, i, j, idx, length;
  
  printf("checking the GetNames request (xcb vs. Xlib)\n");

  fail_if(e != NULL, "xcb: cannot initialize XKB!?\n");

  get_names_reply = xcb_xkb_util_get_names (c, XCB_XKB_ID_USE_CORE_KBD, xcb_xkb_util_all_name_details_mask, &names, &e);
  fail_if(e != NULL, "xcb: xcb_xkb_get_names failed\n");

  fail_if(XkbGetNames(d, XkbAllNamesMask, p) != Success, 
	  "Xlib: XkbGetNames() failed\n");

  /* check if serialize and unpack work properly */
  printf("  testing serialize & unpack for switch with variable fields\n");
  names_buffer = xcb_xkb_get_names_value_list(get_names_reply);
  l0 = xcb_xkb_get_names_value_list_unpack (names_buffer, 
					    get_names_reply->nTypes,
					    get_names_reply->indicators,
					    get_names_reply->virtualMods,
					    get_names_reply->groupNames,
					    get_names_reply->nKeys,
					    get_names_reply->nKeyAliases,
					    get_names_reply->nRadioGroups,
					    get_names_reply->which,
					    &names);
  l1 = xcb_xkb_get_names_value_list_serialize (&new_buffer,
					       get_names_reply->nTypes,
					       get_names_reply->indicators,
					       get_names_reply->virtualMods,
					       get_names_reply->groupNames,
					       get_names_reply->nKeys,
					       get_names_reply->nKeyAliases,
					       get_names_reply->nRadioGroups,
					       get_names_reply->which,
					       &names);
  l2 = xcb_xkb_get_names_value_list_unpack (new_buffer, 
					    get_names_reply->nTypes,
					    get_names_reply->indicators,
					    get_names_reply->virtualMods,
					    get_names_reply->groupNames,
					    get_names_reply->nKeys,
					    get_names_reply->nKeyAliases,
					    get_names_reply->nRadioGroups,
					    get_names_reply->which,
					    &names); 
  free(new_buffer);
  fail_unless(l0 == l1, "xcb: serializing a previously unpacked switch gives a different buffer length!");
  fail_unless(l2 == l1, "xcb: unpacking a previously serialized switch gives a different buffer length!");
  
  xlib_result = p;
  xcb_result = names;
  /* 1. check fixed size fields */
  printf("  checking fixed size fields\n");
  fail_unless(xcb_result.keycodesName == xlib_result->names->keycodes, NULL);
  fail_unless(xcb_result.geometryName == xlib_result->names->geometry, NULL);
  fail_unless(xcb_result.symbolsName == xlib_result->names->symbols, NULL);
  fail_unless(xcb_result.physSymbolsName == xlib_result->names->phys_symbols, NULL);
  fail_unless(xcb_result.typesName == xlib_result->names->types, NULL);
  fail_unless(xcb_result.compatName == xlib_result->names->compat, NULL);

  /* 2. check some variable size fields */
  /* typeNames */
  length = xcb_xkb_get_names_value_list_type_names_length(get_names_reply, 
							  &xcb_result);
  printf("  checking typenames (%d items)\n", length); 
  fail_unless(length == xlib_result->map->num_types, NULL);
  for(i=0; i<length; i++) {
    fail_unless(xcb_result.typeNames[i] == xlib_result->map->types[i].name, NULL);
  }

  /* ktLevelNames - the length of the list is calculated with sumof */
  length = xcb_xkb_get_names_value_list_n_levels_per_type_length(get_names_reply, 
								 &xcb_result);
  printf("  checking ktLevelNames (%d items), special case: sumof expression\n", length); 
  fail_unless(length == xlib_result->map->num_types, NULL);
  idx = 0;
  for(i=0; i<length; i++) {
    int n_levels = xcb_result.nLevelsPerType[i];
    for(j=0; j<n_levels; j++) {
      fail_unless(xcb_result.ktLevelNames[idx] == xlib_result->map->types[i].level_names[j], NULL);
      idx++;
    }
  }
  
  /* groups */
  length = xcb_xkb_get_names_value_list_groups_length(get_names_reply, &xcb_result);
  printf("  checking groups (%d items)\n", length); 
  // the number of elements is calculated on-the-fly in Xlib (see _XkbReadAtoms)
  for(i=0; i<length; i++) {
    fail_unless(xcb_result.groups[i] == xlib_result->names->groups[i], NULL);
  }
  
  /* keyAliases */
  length = xcb_xkb_get_names_value_list_key_aliases_length(get_names_reply, &xcb_result);
  printf("  checking keyAliases (%d items)\n", length); 
  fail_unless(length == xlib_result->names->num_key_aliases);
  for(i=0; i<length; i++) {
    for(j=0; j<4; j++) {
      fail_unless(xcb_result.keyAliases[i].real[j] == xlib_result->names->key_aliases[i].real[j]);
      fail_unless(xcb_result.keyAliases[i].alias[j] == xlib_result->names->key_aliases[i].alias[j]);
    }
  }

  XCloseDisplay (d);
  xcb_disconnect (c);

  printf("... done!\n\n");
}
END_TEST

/* 
 * check the result of issuing a GetKbdByName request with Xlib and xcb
 * test for special case: nested switch statements
 */
START_TEST(check_xkb_get_kbd_by_name_request)
{
  /* xcb */
  xcb_connection_t *c;
  xcb_generic_error_t *e = NULL;  
  xcb_xkb_use_extension_reply_t *reply;
  xcb_xkb_get_kbd_by_name_request_t aux, *aux_p;
  xcb_xkb_get_kbd_by_name_cookie_t cookie;
  xcb_xkb_get_kbd_by_name_reply_t *get_kbd_reply;
  xcb_xkb_get_kbd_by_name_replies_t names = {0};
  xcb_xkb_key_type_iterator_t iter;
  void *buffer = NULL;
  char *buf = NULL;
  int l0, l1, l2, i, j, idx, length;  

  /* Xlib */
  Display *d = XkbOpenDisplay(NULL, 0, 0, 0, 0, 0);
  XkbDescPtr xlib_result = XkbGetKeyboardByName(d, XkbUseCoreKbd, NULL, 
						//XkbGBN_AllComponentsMask,	
						//XkbGBN_AllComponentsMask, 
						XkbGBN_TypesMask, XkbGBN_TypesMask,
						False); 
  fail_if(0 == xlib_result, "Xlib: XkbGetKeyboardByName() failed\n");

  printf("checking the GetKbdByName request (xcb vs. Xlib)\n");

  c = xcb_connect (NULL, NULL);
  reply = xcb_xkb_util_query_extension(c, 1, 0, &e);
  fail_if(e != NULL, "xcb: cannot initialize XKB!?\n");

  /* in the protocol description, variable size fields are followed by fixed size fields 
     in the request, no switch is involved */
  aux.deviceSpec = XCB_XKB_ID_USE_CORE_KBD ;
  aux.need = xcb_xkb_util_all_gbn_details_mask;
  aux.want = xcb_xkb_util_all_gbn_details_mask;
  aux.load = 0;
  aux.pad0 = 0;
  aux.keymapsSpecLen = 0;
  aux.keycodesSpecLen = 0;
  aux.typesSpecLen = 0;
  aux.compatMapSpecLen = 0;
  aux.symbolsSpecLen = 0;
  aux.geometrySpecLen = 0;
  aux_p = &aux;

  printf("  testing serialize/unserialize/sizeof for special case: intermixed variable and fixed size fields\n");
  l0 = xcb_xkb_get_kbd_by_name_serialize(&buffer, &aux, 0, 0, 0, 0, 0, 0);
  l1 = xcb_xkb_get_kbd_by_name_unserialize (buffer, &aux_p);
  l2 = xcb_xkb_get_kbd_by_name_sizeof(buffer);
  fail_unless(l0 == l1, "unserializing a previously serialized data type gives a different buffer length!");
  fail_unless(l0 == l2, "applying sizeof on a previously serialized data type gives a different buffer length!");

  /* compare the structs bytewise */
  for (i=0; i<l0; i++) {
    /* printf("  %d vs. %d\n", ((char *)&aux)[i], ((char *)aux_p)[i]); */
    fail_unless(((char *)&aux)[i] == ((char *)aux_p)[i], 
		"unserialized structure differs from previously serialized one!"); 
  }
  free(buffer);
  buffer = NULL;
  l2 = xcb_xkb_get_kbd_by_name_serialize(&buffer, &aux, 0, 0, 0, 0, 0, 0);
  free(buffer);
  buffer = NULL;
  fail_unless(l0 == l2, "serializing a previously unserialized data type gives a different buffer length!");

  /* explicitly perform the GetKbdByName request */
  printf("  checking request & reply for special case: nested switch statements\n");
  cookie = xcb_xkb_get_kbd_by_name (c, XCB_XKB_ID_USE_CORE_KBD,
				    XCB_XKB_GBN_DETAIL_TYPES, XCB_XKB_GBN_DETAIL_TYPES, 
				    //xcb_xkb_util_all_gbn_details_mask, xcb_xkb_util_all_gbn_details_mask, 
				    0, /* load */
				    0, /* keymapsSpecLen */
				    0, /* keymapsSpec */
				    0, /* keycodesSpecLen */
				    0, /* keycodesSpec */
				    0, /* typesSpecLen */
				    0, /* typesSpec */
				    0, /* compatMapSpecLen */
				    0, /* compatMapSpec */
				    0, /* symbolsSpecLen */
				    0, /* symbolsSpec */
				    0, /* geometrySpecLen */
				    0  /* geometrySpec */);
  get_kbd_reply = xcb_xkb_get_kbd_by_name_reply (c, cookie, &e);
  fail_if(e != NULL, "xcb: xcb_xkb_get_kbd_by_name() failed\n");
  
  printf("  reply->length: %d (xcb)\n", get_kbd_reply->length);  

  buffer = xcb_xkb_get_kbd_by_name_replies (get_kbd_reply);
  l0 = xcb_xkb_get_kbd_by_name_replies_unpack (buffer, get_kbd_reply->reported, &names);  

  if (get_kbd_reply->reported & XCB_XKB_GBN_DETAIL_TYPES) {
    printf("  checking bitcase replies.types (xcb: nTypes=%d, l0=%d)\n", names.types.nTypes, l0);
    fail_unless(xlib_result->device_spec == names.types.typeDeviceID,
		"device_specs differ\n");
    fail_unless(xlib_result->min_key_code == names.types.typeMinKeyCode, 
		"min_key_code differs\n");
    fail_unless(xlib_result->max_key_code == names.types.typeMaxKeyCode, 
		"max_key_code differs\n");
    printf("  contents of some fields: (should be small integers, please 'check by inspection')\n");
    printf("    present: %d\n", names.types.present);
    printf("    first_type %d\n", names.types.firstType);
    printf("    nTypes: %d\n", names.types.nTypes);
    printf("    totalTypes: %d\n", names.types.totalTypes);
    printf("    totalVModMapKeys: %d\n", names.types.totalVModMapKeys);

    /* 
     buf = (char *)buffer;
     for(i=0; i<200; i++) 
     printf("  %d: %d\n", i, buf[i]);
    */    

    iter = xcb_xkb_get_map_map_types_rtrn_iterator((xcb_xkb_get_map_reply_t *)&names.types, &names.types.map);
    l1 = xcb_xkb_get_map_map_types_rtrn_length((xcb_xkb_get_map_reply_t *)&names.types, &names.types.map);
    printf("  checking bitcase replies.types.map.types_rtrn (%d items)\n", l1);
    for(i=0; i<l1; i++) {
      XkbKeyTypePtr xlib_type = &xlib_result->map->types[i];
      xcb_xkb_key_type_t *xcb_type = iter.data;
      fail_unless(xlib_type->mods.mask      == xcb_type->mods_mask);
      fail_unless(xlib_type->mods.real_mods == xcb_type->mods_mods);
      fail_unless(xlib_type->mods.vmods     == xcb_type->mods_vmods);
      fail_unless(xlib_type->num_levels     == xcb_type->numLevels);
      fail_unless(xlib_type->map_count      == xcb_type->nMapEntries);
      fail_unless((0!=xlib_type->preserve)  == xcb_type->hasPreserve);
      xcb_xkb_key_type_next(&iter);
    }
} 
  XCloseDisplay (d);
  xcb_disconnect (c);

  printf("... done!\n\n");
}
END_TEST

Suite *
xkb_test_suite (void)
{
  Suite *s = suite_create ("XKB");

  /* Core test case */
  TCase *tc_core = tcase_create ("Core");
  tcase_add_test (tc_core, check_xkb_get_names_request);
  tcase_add_test (tc_core, check_xkb_get_kbd_by_name_request);
  suite_add_tcase (s, tc_core);

  return s;
}

int
main (void)
{
  int number_failed;
  Suite *s = xkb_test_suite ();
  SRunner *sr = srunner_create (s);
  printf("\n");
  srunner_run_all (sr, CK_NORMAL);
  number_failed = srunner_ntests_failed (sr);
  srunner_free (sr);
  printf("\n");
  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}