#include <X11/Xmd.h>

#include "WINGsP.h"

#include <X11/Xatom.h>


typedef struct W_Window {
    W_Class widgetClass;
    W_View *view;

    struct W_Window *nextPtr;	       /* next in the window list */

    struct W_Window *owner;

    char *title;

    WMPixmap *miniImage;	       /* miniwindow */
    char *miniTitle;

    char *wname;

    WMSize resizeIncrement;
    WMSize baseSize;
    WMSize minSize;
    WMSize maxSize;
    WMPoint minAspect;
    WMPoint maxAspect;

    WMPoint upos;
    WMPoint ppos;

    WMAction *closeAction;
    void *closeData;

    int level;

    struct {
        unsigned style:4;
        unsigned configured:1;
        unsigned documentEdited:1;

        unsigned setUPos:1;
        unsigned setPPos:1;
        unsigned setAspect:1;
    } flags;
} _Window;



typedef struct {
    CARD32 flags;
    CARD32 window_style;
    CARD32 window_level;
    CARD32 reserved;
    Pixmap miniaturize_pixmap;	       /* pixmap for miniaturize button */
    Pixmap close_pixmap;	       /* pixmap for close button */
    Pixmap miniaturize_mask;	       /* miniaturize pixmap mask */
    Pixmap close_mask;		       /* close pixmap mask */
    CARD32 extra_flags;
} GNUstepWMAttributes;

#define GSWindowStyleAttr 	(1<<0)
#define GSWindowLevelAttr 	(1<<1)
#define GSMiniaturizePixmapAttr	(1<<3)
#define GSClosePixmapAttr	(1<<4)
#define GSMiniaturizeMaskAttr	(1<<5)
#define GSCloseMaskAttr		(1<<6)
#define GSExtraFlagsAttr	(1<<7)

/* extra flags */
#define GSDocumentEditedFlag	(1<<0)
#define GSNoApplicationIconFlag	(1<<5)

#define WMFHideOtherApplications	10
#define WMFHideApplication		12



static void willResizeWindow(W_ViewDelegate *, WMView *, unsigned*, unsigned*);

struct W_ViewDelegate _WindowViewDelegate = {
    NULL,
    NULL,
    NULL,
    NULL,
    willResizeWindow
};


#define DEFAULT_WIDTH	400
#define DEFAULT_HEIGHT	180
#define DEFAULT_TITLE	""


static void destroyWindow(_Window *win);

static void handleEvents();

static void realizeWindow();

static void
realizeObserver(void *self, WMNotification *not)
{
    realizeWindow(self);
}


WMWindow*
WMCreatePanelWithStyleForWindow(WMWindow *owner, char *name, int style)
{
    WMWindow *win;

    win = WMCreateWindowWithStyle(owner->view->screen, name, style);
    win->owner = owner;

    return win;
}



WMWindow*
WMCreatePanelForWindow(WMWindow *owner, char *name)
{
    return WMCreatePanelWithStyleForWindow(owner, name,
                                           WMTitledWindowMask
                                           |WMClosableWindowMask
                                           |WMResizableWindowMask);
}


void
WMChangePanelOwner(WMWindow *win, WMWindow *newOwner)
{
    win->owner = newOwner;

    if (win->view->flags.realized && newOwner) {
        XSetTransientForHint(win->view->screen->display, win->view->window,
                             newOwner->view->window);
    }
}



WMWindow*
WMCreateWindow(WMScreen *screen, char *name)
{
    return WMCreateWindowWithStyle(screen, name, WMTitledWindowMask
                                   |WMClosableWindowMask
                                   |WMMiniaturizableWindowMask
                                   |WMResizableWindowMask);
}



WMWindow*
WMCreateWindowWithStyle(WMScreen *screen, char *name, int style)
{
    _Window *win;

    win = wmalloc(sizeof(_Window));
    memset(win, 0, sizeof(_Window));

    win->widgetClass = WC_Window;

    win->view = W_CreateTopView(screen);
    if (!win->view) {
        wfree(win);
        return NULL;
    }
    win->view->self = win;

    win->view->delegate = &_WindowViewDelegate;

    win->wname = wstrdup(name);

    /* add to the window list of the screen (application) */
    win->nextPtr = screen->windowList;
    screen->windowList = win;

    WMCreateEventHandler(win->view, ExposureMask|StructureNotifyMask
                         |ClientMessageMask|FocusChangeMask,
                         handleEvents, win);

    W_ResizeView(win->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);

    WMAddNotificationObserver(realizeObserver, win,
                              WMViewRealizedNotification, win->view);

    win->flags.style = style;

    win->level = WMNormalWindowLevel;

    /* kluge. Find a better solution */
    W_SetFocusOfTopLevel(win->view, win->view);

    return win;
}



static void
setWindowTitle(WMWindow *win, const char *title)
{
    WMScreen *scr= win->view->screen;
    XTextProperty property;
    int result;

    result = XmbTextListToTextProperty(scr->display,
                                       (char**)&title, 1, XStdICCTextStyle,
                                       &property);
    if (result == XNoMemory || result == XLocaleNotSupported) {
        wwarning("window title conversion error... using STRING encoding");
        XStoreName(scr->display, win->view->window, title);
    } else {
        XSetWMName(scr->display, win->view->window, &property);
        if (property.value)
          XFree(property.value);
    }

    XChangeProperty(scr->display, win->view->window,
                    scr->netwmName, scr->utf8String, 8,
                    PropModeReplace, (unsigned char *)title, strlen(title));
}


static void
setMiniwindowTitle(WMWindow *win, const char *title)
{
    WMScreen *scr= win->view->screen;
    XTextProperty property;
    int result;

    result = XmbTextListToTextProperty(scr->display,
                                       (char**)&title, 1, XStdICCTextStyle,
                                       &property);
    if (result == XNoMemory || result == XLocaleNotSupported) {
        wwarning("icon title conversion error..using STRING encoding");
        XSetIconName(scr->display, win->view->window, title);
    } else {
        XSetWMIconName(scr->display, win->view->window, &property);
        if (property.value)
          XFree(property.value);
    }
    
    XChangeProperty(scr->display, win->view->window,
                    scr->netwmIconName, scr->utf8String, 8,
                    PropModeReplace, (unsigned char *)title, strlen(title));
}


static void
setMiniwindow(WMWindow *win, RImage *image)
{
    WMScreen *scr= win->view->screen;
    CARD32 *data;
    int x, y;
    int o;

    if (!image)
      return;

    data = wmalloc((image->width * image->height + 2) * sizeof(CARD32));

    o= 0;
    data[o++] = image->width;
    data[o++] = image->height;

    for (y= 0; y < image->height; y++) {
        for (x= 0; x < image->width; x++) {
            CARD32 pixel;
            int offs= (x+y*image->width);
            
            if (image->format == RRGBFormat)
              pixel= image->data[offs*3]<<16 | image->data[offs*3+1]<<8 | image->data[offs*3+2];
            else
              pixel= image->data[offs*4]<<16 | image->data[offs*4+1]<<8 | image->data[offs*4+2] | image->data[offs*4+3] << 24;

            data[o++]= pixel;
        }
    }

    XChangeProperty(scr->display, win->view->window, scr->netwmIcon,
                    XA_CARDINAL, 32, PropModeReplace,
                    (unsigned char *)data,
                    (image->width * image->height + 2));

    wfree(data);
}


void
WMSetWindowTitle(WMWindow *win, char *title)
{
    if (win->title!=NULL)
        wfree(win->title);
    if (title!=NULL)
        win->title = wstrdup(title);
    else
        win->title = NULL;

    if (win->view->flags.realized) {
        setWindowTitle(win, title);
    }
}




void
WMSetWindowCloseAction(WMWindow *win, WMAction *action, void *clientData)
{
    Atom *atoms = NULL;
    Atom *newAtoms;
    int count;
    WMScreen *scr = win->view->screen;

    if (win->view->flags.realized) {
        if (action && !win->closeAction) {
            if (!XGetWMProtocols(scr->display, win->view->window, &atoms,
                                 &count)) {
                count = 0;
            }
            newAtoms = wmalloc((count+1)*sizeof(Atom));
            if (count > 0)
                memcpy(newAtoms, atoms, count*sizeof(Atom));
            newAtoms[count++] = scr->deleteWindowAtom;
            XSetWMProtocols(scr->display, win->view->window, newAtoms, count);
            if (atoms)
                XFree(atoms);
            wfree(newAtoms);
        } else if (!action && win->closeAction) {
            int i, ncount;

            if (XGetWMProtocols(scr->display, win->view->window, &atoms,
                                &count) && count>0) {
                newAtoms = wmalloc((count-1)*sizeof(Atom));
                ncount = 0;
                for (i=0; i < count; i++) {
                    if (atoms[i]!=scr->deleteWindowAtom) {
                        newAtoms[i] = atoms[i];
                        ncount++;
                    }
                }
                XSetWMProtocols(scr->display, win->view->window, newAtoms,
                                ncount);
                if (atoms)
                    XFree(atoms);
                wfree(newAtoms);
            }
        }
    }
    win->closeAction = action;
    win->closeData = clientData;
}



static void
willResizeWindow(W_ViewDelegate *self, WMView *view,
                 unsigned *width, unsigned *height)
{
    WMWindow *win = (WMWindow*)view->self;

    if (win->minSize.width > 0 && win->minSize.height > 0) {
        if (*width < win->minSize.width)
            *width = win->minSize.width;
        if (*height < win->minSize.height)
            *height = win->minSize.height;
    }

    if (win->maxSize.width > 0 && win->maxSize.height > 0) {
        if (*width > win->maxSize.width)
            *width = win->maxSize.width;
        if (*height > win->maxSize.height)
            *height = win->maxSize.height;
    }
}


static void
setSizeHints(WMWindow *win)
{
    XSizeHints *hints;

    hints = XAllocSizeHints();
    if (!hints) {
        wwarning("could not allocate memory for window size hints");
        return;
    }

    hints->flags = 0;

    if (win->flags.setPPos) {
        hints->flags |= PPosition;
        hints->x = win->ppos.x;
        hints->y = win->ppos.y;
    }
    if (win->flags.setUPos) {
        hints->flags |= USPosition;
        hints->x = win->upos.x;
        hints->y = win->upos.y;
    }
    if (win->minSize.width>0 && win->minSize.height>0) {
        hints->flags |= PMinSize;
        hints->min_width = win->minSize.width;
        hints->min_height = win->minSize.height;
    }
    if (win->maxSize.width>0 && win->maxSize.height>0) {
        hints->flags |= PMaxSize;
        hints->max_width = win->maxSize.width;
        hints->max_height = win->maxSize.height;
    }
    if (win->baseSize.width>0 && win->baseSize.height>0) {
        hints->flags |= PBaseSize;
        hints->base_width = win->baseSize.width;
        hints->base_height = win->baseSize.height;
    }
    if (win->resizeIncrement.width>0 && win->resizeIncrement.height>0) {
        hints->flags |= PResizeInc;
        hints->width_inc = win->resizeIncrement.width;
        hints->height_inc = win->resizeIncrement.height;
    }
    if (win->flags.setAspect) {
        hints->flags |= PAspect;
        hints->min_aspect.x = win->minAspect.x;
        hints->min_aspect.y = win->minAspect.y;
        hints->max_aspect.x = win->maxAspect.x;
        hints->max_aspect.y = win->maxAspect.y;
    }


    if (hints->flags) {
        XSetWMNormalHints(win->view->screen->display, win->view->window, hints);
    }
    XFree(hints);
}



static void
writeGNUstepWMAttr(WMScreen *scr, Window window, GNUstepWMAttributes *attr)
{
    unsigned long data[9];

    /* handle idiot compilers where array of CARD32 != struct of CARD32 */
    data[0] = attr->flags;
    data[1] = attr->window_style;
    data[2] = attr->window_level;
    data[3] = 0;		       /* reserved */
    /* The X protocol says XIDs are 32bit */
    data[4] = attr->miniaturize_pixmap;
    data[5] = attr->close_pixmap;
    data[6] = attr->miniaturize_mask;
    data[7] = attr->close_mask;
    data[8] = attr->extra_flags;
    XChangeProperty(scr->display, window, scr->attribsAtom, scr->attribsAtom,
                    32, PropModeReplace,  (unsigned char *)data, 9);
}


static void
setWindowMakerHints(WMWindow *win)
{
    GNUstepWMAttributes attribs;
    WMScreen *scr = WMWidgetScreen(win);

    memset(&attribs, 0, sizeof(GNUstepWMAttributes));
    attribs.flags = GSWindowStyleAttr|GSWindowLevelAttr|GSExtraFlagsAttr;
    attribs.window_style = win->flags.style;
    attribs.window_level = win->level;
    if (win->flags.documentEdited)
        attribs.extra_flags = GSDocumentEditedFlag;
    else
        attribs.extra_flags = 0;

    writeGNUstepWMAttr(scr, win->view->window, &attribs);
}


static void
realizeWindow(WMWindow *win)
{
    XWMHints *hints;
    XClassHint *classHint;
    WMScreen *scr = win->view->screen;
    Atom atoms[4];
    int count;

    classHint = XAllocClassHint();
    classHint->res_name = win->wname;
    classHint->res_class = WMGetApplicationName();
    XSetClassHint(scr->display, win->view->window, classHint);
    XFree(classHint);

    hints = XAllocWMHints();
    hints->flags = 0;
    if (!scr->aflags.simpleApplication) {
        hints->flags |= WindowGroupHint;
        hints->window_group = scr->groupLeader;
    }
    if (win->miniImage) {
        hints->flags |= IconPixmapHint;
        hints->icon_pixmap = WMGetPixmapXID(win->miniImage);
        hints->icon_mask = WMGetPixmapMaskXID(win->miniImage);
        if (hints->icon_mask != None) {
            hints->flags |= IconMaskHint;
        }
    }
    if (hints->flags != 0)
        XSetWMHints(scr->display, win->view->window, hints);
    XFree(hints);

    count = 0;
    if (win->closeAction) {
        atoms[count++] = scr->deleteWindowAtom;
    }

    if (count>0)
        XSetWMProtocols(scr->display, win->view->window, atoms, count);

    if (win->title || win->miniTitle)
        XmbSetWMProperties(scr->display, win->view->window, win->title,
                           win->miniTitle, NULL, 0, NULL, NULL, NULL);

    setWindowMakerHints(win);

    setSizeHints(win);

    if (win->owner) {
        XSetTransientForHint(scr->display, win->view->window,
                             win->owner->view->window);
    }
    
    if (win->title)
      setWindowTitle(win, win->title);
}



void
WMSetWindowAspectRatio(WMWindow *win, int minX, int minY,
                       int maxX, int maxY)
{
    win->flags.setAspect = 1;
    win->minAspect.x = minX;
    win->minAspect.y = minY;
    win->maxAspect.x = maxX;
    win->maxAspect.y = maxY;
    if (win->view->flags.realized)
        setSizeHints(win);
}



void
WMSetWindowInitialPosition(WMWindow *win, int x, int y)
{
    win->flags.setPPos = 1;
    win->ppos.x = x;
    win->ppos.y = y;
    if (win->view->flags.realized)
        setSizeHints(win);
    WMMoveWidget(win, x, y);
}



void
WMSetWindowUserPosition(WMWindow *win, int x, int y)
{
    win->flags.setUPos = 1;
    win->upos.x = x;
    win->upos.y = y;
    if (win->view->flags.realized)
        setSizeHints(win);
    WMMoveWidget(win, x, y);
}




void
WMSetWindowMinSize(WMWindow *win, unsigned width, unsigned height)
{
    win->minSize.width = width;
    win->minSize.height = height;
    if (win->view->flags.realized)
        setSizeHints(win);
}



void
WMSetWindowMaxSize(WMWindow *win, unsigned width, unsigned height)
{
    win->maxSize.width = width;
    win->maxSize.height = height;
    if (win->view->flags.realized)
        setSizeHints(win);
}


void
WMSetWindowBaseSize(WMWindow *win, unsigned width, unsigned height)
{
    /* TODO: validate sizes */
    win->baseSize.width = width;
    win->baseSize.height = height;
    if (win->view->flags.realized)
        setSizeHints(win);
}


void
WMSetWindowResizeIncrements(WMWindow *win, unsigned wIncr, unsigned hIncr)
{
    win->resizeIncrement.width = wIncr;
    win->resizeIncrement.height = hIncr;
    if (win->view->flags.realized)
        setSizeHints(win);
}


void
WMSetWindowLevel(WMWindow *win, int level)
{
    win->level = level;
    if (win->view->flags.realized)
        setWindowMakerHints(win);
}


void
WMSetWindowDocumentEdited(WMWindow *win, Bool flag)
{
    flag = ((flag==0) ? 0 : 1);
    if (win->flags.documentEdited != flag) {
        win->flags.documentEdited = flag;
        if (win->view->flags.realized)
            setWindowMakerHints(win);
    }
}


void
WMSetWindowMiniwindowImage(WMWindow *win, RImage *image)
{
    if (win->view->flags.realized)
        setMiniwindow(win, image);
}


void
WMSetWindowMiniwindowPixmap(WMWindow *win, WMPixmap *pixmap)
{
    if ((win->miniImage && !pixmap) || (!win->miniImage && pixmap)) {
        if (win->miniImage)
            WMReleasePixmap(win->miniImage);

        if (pixmap)
            win->miniImage = WMRetainPixmap(pixmap);
        else
            win->miniImage = NULL;

        if (win->view->flags.realized) {
            XWMHints *hints;

            hints = XGetWMHints(win->view->screen->display, win->view->window);
            if (!hints) {
                hints = XAllocWMHints();
                if (!hints) {
                    wwarning("could not allocate memory for WM hints");
                    return;
                }
                hints->flags = 0;
            }
            if (pixmap) {
                hints->flags |= IconPixmapHint;
                hints->icon_pixmap = WMGetPixmapXID(pixmap);
                hints->icon_mask = WMGetPixmapMaskXID(pixmap);
                if (hints->icon_mask != None) {
                    hints->flags |= IconMaskHint;
                }
            }
            XSetWMHints(win->view->screen->display, win->view->window, hints);
            XFree(hints);
        }
    }
}


void
WMSetWindowMiniwindowTitle(WMWindow *win, char *title)
{
    if ((win->miniTitle && !title) || (!win->miniTitle && title)
        || (title && win->miniTitle && strcoll(title, win->miniTitle)!=0)) {
        if (win->miniTitle)
            wfree(win->miniTitle);

        if (title)
            win->miniTitle = wstrdup(title);
        else
            win->miniTitle = NULL;

        if (win->view->flags.realized) {
            setMiniwindowTitle(win, title);
        }
    }
}


void
WMCloseWindow(WMWindow *win)
{
    WMUnmapWidget(win);
    /* withdraw the window */
    if (win->view->flags.realized)
        XWithdrawWindow(win->view->screen->display, win->view->window,
                        win->view->screen->screen);
}


static void
handleEvents(XEvent *event, void *clientData)
{
    _Window *win = (_Window*)clientData;
    W_View *view = win->view;


    switch (event->type) {
    case ClientMessage:
        if (event->xclient.message_type == win->view->screen->protocolsAtom
            && event->xclient.format == 32
            && event->xclient.data.l[0]==win->view->screen->deleteWindowAtom) {

            if (win->closeAction) {
                (*win->closeAction)(win, win->closeData);
            }
        }
        break;
        /*
         * was causing windows to ignore commands like closeWindow
         * after the windows is iconized/restored or a workspace change
         * if this is really needed, put the MapNotify portion too and
         * fix the restack bug in wmaker
         case UnmapNotify:
         WMUnmapWidget(win);
         break;
         *
         case MapNotify:
         WMMapWidget(win);
         break;

         */
    case DestroyNotify:
        destroyWindow(win);
        break;

    case ConfigureNotify:
        if (event->xconfigure.width != view->size.width
            || event->xconfigure.height != view->size.height) {

            view->size.width = event->xconfigure.width;
            view->size.height = event->xconfigure.height;

            if (view->flags.notifySizeChanged) {
                WMPostNotificationName(WMViewSizeDidChangeNotification,
                                       view, NULL);
            }
        }
        if (event->xconfigure.x != view->pos.x
            || event->xconfigure.y != view->pos.y) {

            if (event->xconfigure.send_event) {
                view->pos.x = event->xconfigure.x;
                view->pos.y = event->xconfigure.y;
            } else {
                Window foo;

                XTranslateCoordinates(view->screen->display,
                                      view->window, view->screen->rootWin,
                                      event->xconfigure.x, event->xconfigure.y,
                                      &view->pos.x, &view->pos.y, &foo);
            }
        }
        break;
    }
}




static void
destroyWindow(_Window *win)
{
    WMScreen *scr = win->view->screen;

    WMRemoveNotificationObserver(win);

    if (scr->windowList == win) {
        scr->windowList = scr->windowList->nextPtr;
    } else {
        WMWindow *ptr;
        ptr = scr->windowList;

        if (ptr) {
            while (ptr->nextPtr) {
                if (ptr->nextPtr==win) {
                    ptr->nextPtr = ptr->nextPtr->nextPtr;
                    break;
                }
                ptr = ptr->nextPtr;
            }
        }
    }

    if (win->title) {
        wfree(win->title);
    }

    if (win->miniTitle) {
        wfree(win->miniTitle);
    }

    if (win->miniImage) {
        WMReleasePixmap(win->miniImage);
    }

    if (win->wname)
        wfree(win->wname);

    wfree(win);
}