/*
   Copyright (c) 2002  XFree86 Inc
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <X11/Xlibint.h>
#include <X11/Xutil.h>
#include <X11/extensions/Xext.h>
#include <X11/extensions/extutil.h>
#include <X11/extensions/XResproto.h>
#include <X11/extensions/XRes.h>
#include <assert.h>
#include <limits.h>

static XExtensionInfo _xres_ext_info_data;
static XExtensionInfo *xres_ext_info = &_xres_ext_info_data;
static const char *xres_extension_name = XRES_NAME;

#define XResCheckExtension(dpy,i,val) \
  XextCheckExtension (dpy, i, xres_extension_name, val)

static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xres_ext_info)

static XExtensionHooks xres_extension_hooks = {
    NULL,                               /* create_gc */
    NULL,                               /* copy_gc */
    NULL,                               /* flush_gc */
    NULL,                               /* free_gc */
    NULL,                               /* create_font */
    NULL,                               /* free_font */
    close_display,                      /* close_display */
    NULL,                               /* wire_to_event */
    NULL,                               /* event_to_wire */
    NULL,                               /* error */
    NULL,                               /* error_string */
};

static XEXT_GENERATE_FIND_DISPLAY (find_display, xres_ext_info,
                                   xres_extension_name,
                                   &xres_extension_hooks,
                                   0, NULL)

Bool XResQueryExtension (
    Display *dpy,
    int *event_base_return,
    int *error_base_return
)
{
    XExtDisplayInfo *info = find_display (dpy);

    if (XextHasExtension(info)) {
        *event_base_return = info->codes->first_event;
        *error_base_return = info->codes->first_error;
        return True;
    } else {
        return False;
    }
}

Status XResQueryVersion(
    Display *dpy,
    int *major_version_return,
    int *minor_version_return
)
{
    XExtDisplayInfo *info = find_display (dpy);
    xXResQueryVersionReply rep;
    xXResQueryVersionReq *req;

    XResCheckExtension (dpy, info, 0);

    LockDisplay (dpy);
    GetReq (XResQueryVersion, req);
    req->reqType = info->codes->major_opcode;
    req->XResReqType = X_XResQueryVersion;
    req->client_major = XRES_MAJOR_VERSION;
    req->client_minor = XRES_MINOR_VERSION;
    if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
        UnlockDisplay (dpy);
        SyncHandle ();
        return 0;
    }
    *major_version_return = rep.server_major;
    *minor_version_return = rep.server_minor;
    UnlockDisplay (dpy);
    SyncHandle ();
    return 1;
}


Status XResQueryClients (
    Display *dpy,
    int *num_clients,
    XResClient **clients
)
{
    XExtDisplayInfo *info = find_display (dpy);
    xXResQueryClientsReq *req;
    xXResQueryClientsReply rep;
    XResClient *clnts;
    int result = 0;

    *num_clients = 0;
    *clients = NULL;

    XResCheckExtension (dpy, info, 0);

    LockDisplay (dpy);
    GetReq (XResQueryClients, req);
    req->reqType = info->codes->major_opcode;
    req->XResReqType = X_XResQueryClients;
    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
        UnlockDisplay (dpy);
        SyncHandle ();
        return 0;
    }

    if(rep.num_clients) {
        if (rep.num_clients < (INT_MAX / sizeof(XResClient)))
            clnts = Xmalloc(sizeof(XResClient) * rep.num_clients);
        else
            clnts = NULL;

        if (clnts != NULL) {
            xXResClient scratch;
            int i;

            for(i = 0; i < rep.num_clients; i++) {
                _XRead(dpy, (char*)&scratch, sz_xXResClient);
                clnts[i].resource_base = scratch.resource_base;
                clnts[i].resource_mask = scratch.resource_mask;
            }
            *clients = clnts;
            *num_clients = rep.num_clients;
            result = 1;
        } else {
            _XEatDataWords(dpy, rep.length);
        }
    }

    UnlockDisplay (dpy);
    SyncHandle ();
    return result;
}

Status XResQueryClientResources (
    Display *dpy,
    XID xid,
    int *num_types,
    XResType **types
)
{
    XExtDisplayInfo *info = find_display (dpy);
    xXResQueryClientResourcesReq *req;
    xXResQueryClientResourcesReply rep;
    XResType *typs;
    int result = 0;

    *num_types = 0;
    *types = NULL;

    XResCheckExtension (dpy, info, 0);

    LockDisplay (dpy);
    GetReq (XResQueryClientResources, req);
    req->reqType = info->codes->major_opcode;
    req->XResReqType = X_XResQueryClientResources;
    req->xid = xid;
    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
        UnlockDisplay (dpy);
        SyncHandle ();
        return 0;
    }

    if(rep.num_types) {
        if (rep.num_types < (INT_MAX / sizeof(XResType)))
            typs = Xmalloc(sizeof(XResType) * rep.num_types);
        else
            typs = NULL;

        if (typs != NULL) {
            xXResType scratch;
            int i;

            for(i = 0; i < rep.num_types; i++) {
                _XRead(dpy, (char*)&scratch, sz_xXResType);
                typs[i].resource_type = scratch.resource_type;
                typs[i].count = scratch.count;
            }
            *types = typs;
            *num_types = rep.num_types;
            result = 1;
        } else {
            _XEatDataWords(dpy, rep.length);
        }
    }

    UnlockDisplay (dpy);
    SyncHandle ();
    return result;
}

Status XResQueryClientPixmapBytes (
    Display *dpy,
    XID xid,
    unsigned long *bytes
)
{
    XExtDisplayInfo *info = find_display (dpy);
    xXResQueryClientPixmapBytesReq *req;
    xXResQueryClientPixmapBytesReply rep;

    *bytes = 0;

    XResCheckExtension (dpy, info, 0);

    LockDisplay (dpy);
    GetReq (XResQueryClientPixmapBytes, req);
    req->reqType = info->codes->major_opcode;
    req->XResReqType = X_XResQueryClientPixmapBytes;
    req->xid = xid;
    if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
        UnlockDisplay (dpy);
        SyncHandle ();
        return 0;
    }

#ifdef LONG64
    *bytes = (rep.bytes_overflow * 4294967296UL) + rep.bytes;
#else
    *bytes = rep.bytes_overflow ? 0xffffffff : rep.bytes;
#endif

    UnlockDisplay (dpy);
    SyncHandle ();
    return 1;
}

static Bool ReadClientValues(
   Display              *dpy,
   long                 num_ids,
   XResClientIdValue   *client_ids /* out */
)
{
    int c;
    for (c = 0; c < num_ids; ++c) {
        XResClientIdValue* client = client_ids + c;
        long int value;
        _XRead32 (dpy, &value, 4);
        client->spec.client = value;
        _XRead32 (dpy, &value, 4);
        client->spec.mask = value;
        _XRead32 (dpy, &value, 4);
        client->length = value;
        client->value = malloc(client->length);
        _XRead (dpy, client->value, client->length);
    }
    return True;
}

/* Returns an array of uint32_t values, not an array of long */
Status XResQueryClientIds (
   Display            *dpy,
   long                num_specs,
   XResClientIdSpec   *client_specs,   /* in */
   long               *num_ids,        /* out */
   XResClientIdValue **client_ids      /* out */
)
{
    XExtDisplayInfo *info = find_display (dpy);
    xXResQueryClientIdsReq *req;
    xXResQueryClientIdsReply rep;
    int c;

    *num_ids = 0;

    XResCheckExtension (dpy, info, 0);
    LockDisplay (dpy);
    GetReq (XResQueryClientIds, req);
    req->reqType = info->codes->major_opcode;
    req->XResReqType = X_XResQueryClientIds;
    req->length += num_specs * 2; /* 2 longs per client id spec */
    req->numSpecs = num_specs;

    for (c = 0; c < num_specs; ++c) {
        Data32(dpy, &client_specs[c].client, 4);
        Data32(dpy, &client_specs[c].mask, 4);
    }

    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
        goto error;
    }

    *client_ids = calloc(rep.numIds, sizeof(**client_ids));
    *num_ids = rep.numIds;

    if (!ReadClientValues(dpy, *num_ids, *client_ids)) {
        goto error;
    }

    UnlockDisplay (dpy);
    SyncHandle ();
    return Success;

 error:
    XResClientIdsDestroy (*num_ids, *client_ids);
    *client_ids = NULL;

    UnlockDisplay (dpy);
    SyncHandle ();
    return !Success;
}

void XResClientIdsDestroy (
   long                num_ids,
   XResClientIdValue  *client_ids
)
{
    int c;
    for (c = 0; c < num_ids; ++c) {
        free(client_ids[c].value);
    }
    free(client_ids);
}

XResClientIdType XResGetClientIdType(
    XResClientIdValue* value
)
{
    int bit;
    XResClientIdType idType = 0;
    Bool found = False;
    for (bit = 0; bit < XRES_CLIENT_ID_NR; ++bit) {
        if (value->spec.mask & (1 << bit)) {
            assert(!found);
            found = True;
            idType = bit;
        }
    }

    assert(found);

    return idType;
}

pid_t XResGetClientPid(
    XResClientIdValue* value
)
{
    if (value->spec.mask & XRES_CLIENT_ID_PID_MASK && value->length >= 4) {
        return (pid_t) * (CARD32*) value->value;
    } else {
        return (pid_t) -1;
    }
}

static Status ReadResourceSizeSpec(
   Display               *dpy,
   XResResourceSizeSpec  *size
)
{
    long int value;
    _XRead32(dpy, &value, 4);
    size->spec.resource = value;
    _XRead32(dpy, &value, 4);
    size->spec.type = value;
    _XRead32(dpy, &value, 4);
    size->bytes = value;
    _XRead32(dpy, &value, 4);
    size->ref_count = value;
    _XRead32(dpy, &value, 4);
    size->use_count = value;
    return 0;
}

static Status ReadResourceSizeValues(
   Display                *dpy,
   long                    num_sizes,
   XResResourceSizeValue  *sizes)
{
    int c;
    int d;
    for (c = 0; c < num_sizes; ++c) {
        long int num;
        ReadResourceSizeSpec(dpy, &sizes[c].size);
        _XRead32(dpy, &num, 4);
        sizes[c].num_cross_references = num;
        sizes[c].cross_references = num ? calloc(num, sizeof(*sizes[c].cross_references)) : NULL;
        for (d = 0; d < num; ++d) {
            ReadResourceSizeSpec(dpy, &sizes[c].cross_references[d]);
        }
    }
    return Success;
}

Status XResQueryResourceBytes (
   Display            *dpy,
   XID                 client,
   long                num_specs,
   XResResourceIdSpec *resource_specs, /* in */
   long               *num_sizes, /* out */
   XResResourceSizeValue **sizes /* out */
)
{
    XExtDisplayInfo *info = find_display (dpy);
    xXResQueryResourceBytesReq *req;
    xXResQueryResourceBytesReply rep;
    int c;

    *num_sizes = 0;

    XResCheckExtension (dpy, info, 0);

    LockDisplay (dpy);
    GetReq (XResQueryResourceBytes, req);
    req->reqType = info->codes->major_opcode;
    req->XResReqType = X_XResQueryResourceBytes;
    req->length += num_specs * 2; /* 2 longs per client id spec */
    req->client = client;
    req->numSpecs = num_specs;

    for (c = 0; c < num_specs; ++c) {
        Data32(dpy, &resource_specs[c].resource, 4);
        Data32(dpy, &resource_specs[c].type, 4);
    }

    *num_sizes = 0;
    *sizes = NULL;

    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
        goto error;
    }

    *sizes = calloc(rep.numSizes, sizeof(**sizes));
    *num_sizes = rep.numSizes;

    if (ReadResourceSizeValues(dpy, *num_sizes, *sizes) != Success) {
        goto error;
    }

    UnlockDisplay (dpy);
    SyncHandle ();
    return Success;

 error:
    XResResourceSizeValuesDestroy(*num_sizes, *sizes);

    UnlockDisplay (dpy);
    SyncHandle ();
    return !Success;
}

void XResResourceSizeValuesDestroy (
   long                num_sizes,
   XResResourceSizeValue *sizes
)
{
    int c;
    for (c = 0; c < num_sizes; ++c) {
        free(sizes[c].cross_references);
    }
    free(sizes);
}
