/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

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

#include "SDL_endian.h"
#include "SDL_timer.h"
#include "SDL_thread.h"
#include "SDL_video.h"
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
#include "SDL_ph_video.h"
#include "SDL_ph_modes_c.h"
#include "SDL_ph_image_c.h"
#include "SDL_ph_events_c.h"
#include "SDL_ph_mouse_c.h"
#include "SDL_ph_wm_c.h"
#include "SDL_ph_gl.h"
#include "SDL_phyuv_c.h"
#include "../blank_cursor.h"

static int ph_VideoInit(_THIS, SDL_PixelFormat * vformat);
static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface * current, int width,
                                    int height, int bpp, Uint32 flags);
static int ph_SetColors(_THIS, int firstcolor, int ncolors,
                        SDL_Color * colors);
static void ph_VideoQuit(_THIS);
static void ph_DeleteDevice(SDL_VideoDevice * device);

static int phstatus = -1;

static int
ph_Available(void)
{
    if (phstatus != 0) {
        phstatus = PtInit(NULL);
        if (phstatus == 0) {
            return 1;
        } else {
            return 0;
        }
    }
    return 1;
}

static SDL_VideoDevice *
ph_CreateDevice(int devindex)
{
    SDL_VideoDevice *device;

    /* Initialize all variables that we clean on shutdown */
    device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
    if (device) {
        SDL_memset(device, 0, (sizeof *device));
        device->hidden = (struct SDL_PrivateVideoData *)
            SDL_malloc((sizeof *device->hidden));
        device->gl_data = NULL;
    }
    if ((device == NULL) || (device->hidden == NULL)) {
        SDL_OutOfMemory();
        ph_DeleteDevice(device);
        return NULL;
    }
    SDL_memset(device->hidden, 0, (sizeof *device->hidden));

    /* Set the driver flags */
    device->handles_any_size = 1;

    /* Set the function pointers */
    device->CreateYUVOverlay = ph_CreateYUVOverlay;
    device->VideoInit = ph_VideoInit;
    device->ListModes = ph_ListModes;
    device->SetVideoMode = ph_SetVideoMode;
    device->ToggleFullScreen = ph_ToggleFullScreen;
    device->UpdateMouse = ph_UpdateMouse;
    device->SetColors = ph_SetColors;
    device->UpdateRects = NULL; /* set up in ph_SetupUpdateFunction */
    device->VideoQuit = ph_VideoQuit;
    device->AllocHWSurface = ph_AllocHWSurface;
    device->CheckHWBlit = ph_CheckHWBlit;
    device->FillHWRect = ph_FillHWRect;
    device->SetHWColorKey = ph_SetHWColorKey;
    device->SetHWAlpha = ph_SetHWAlpha;
    device->LockHWSurface = ph_LockHWSurface;
    device->UnlockHWSurface = ph_UnlockHWSurface;
    device->FlipHWSurface = ph_FlipHWSurface;
    device->FreeHWSurface = ph_FreeHWSurface;
    device->SetCaption = ph_SetCaption;
    device->SetIcon = NULL;
    device->IconifyWindow = ph_IconifyWindow;
    device->GrabInput = ph_GrabInput;
    device->GetWMInfo = ph_GetWMInfo;
    device->FreeWMCursor = ph_FreeWMCursor;
    device->CreateWMCursor = ph_CreateWMCursor;
    device->ShowWMCursor = ph_ShowWMCursor;
    device->WarpWMCursor = ph_WarpWMCursor;
    device->MoveWMCursor = NULL;
    device->CheckMouseMode = ph_CheckMouseMode;
    device->InitOSKeymap = ph_InitOSKeymap;
    device->PumpEvents = ph_PumpEvents;

    /* OpenGL support. */
#if SDL_VIDEO_OPENGL
    device->GL_MakeCurrent = ph_GL_MakeCurrent;
    device->GL_SwapBuffers = ph_GL_SwapBuffers;
    device->GL_GetAttribute = ph_GL_GetAttribute;
    device->GL_LoadLibrary = ph_GL_LoadLibrary;
    device->GL_GetProcAddress = ph_GL_GetProcAddress;
#endif /* SDL_VIDEO_OPENGL */

    device->free = ph_DeleteDevice;

    return device;
}

VideoBootStrap ph_bootstrap = {
    "photon", "QNX Photon video output",
    ph_Available, ph_CreateDevice
};

static void
ph_DeleteDevice(SDL_VideoDevice * device)
{
    if (device) {
        if (device->hidden) {
            SDL_free(device->hidden);
            device->hidden = NULL;
        }
        if (device->gl_data) {
            SDL_free(device->gl_data);
            device->gl_data = NULL;
        }
        SDL_free(device);
        device = NULL;
    }
}

static PtWidget_t *
ph_CreateWindow(_THIS)
{
    PtWidget_t *widget;

    widget = PtCreateWidget(PtWindow, NULL, 0, NULL);

    return widget;
}

static int
ph_SetupWindow(_THIS, int w, int h, int flags)
{
    PtArg_t args[32];
    PhPoint_t pos = { 0, 0 };
    PhDim_t *olddim;
    PhDim_t dim = { w, h };
    PhRect_t desktopextent;
    int nargs = 0;
    const char *windowpos;
    const char *iscentered;
    int x, y;

    /* check if window size has been changed by Window Manager */
    PtGetResource(window, Pt_ARG_DIM, &olddim, 0);
    if ((olddim->w != w) || (olddim->h != h)) {
        PtSetArg(&args[nargs++], Pt_ARG_DIM, &dim, 0);
    }

    if ((flags & SDL_RESIZABLE) == SDL_RESIZABLE) {
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE,
                 Ph_WM_CLOSE);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE,
                 Ph_WM_MAX | Ph_WM_RESTORE | Ph_WM_RESIZE);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
                 Ph_WM_RESIZE | Ph_WM_MOVE | Ph_WM_CLOSE | Ph_WM_MAX |
                 Ph_WM_RESTORE);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE,
                 Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_MAX |
                 Ph_WM_RENDER_COLLAPSE | Ph_WM_RENDER_RETURN);
        PtSetArg(&args[nargs++], Pt_ARG_RESIZE_FLAGS, Pt_TRUE,
                 Pt_RESIZE_XY_AS_REQUIRED);
    } else {
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE,
                 Ph_WM_RESIZE | Ph_WM_MAX | Ph_WM_RESTORE | Ph_WM_CLOSE);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_FALSE,
                 Ph_WM_RESIZE | Ph_WM_MAX | Ph_WM_RESTORE);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
                 Ph_WM_MOVE | Ph_WM_CLOSE);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE,
                 Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_MAX |
                 Ph_WM_RENDER_COLLAPSE | Ph_WM_RENDER_RETURN);
        PtSetArg(&args[nargs++], Pt_ARG_RESIZE_FLAGS, Pt_FALSE,
                 Pt_RESIZE_XY_AS_REQUIRED);
    }

    if (((flags & SDL_NOFRAME) == SDL_NOFRAME)
        || ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)) {
        if ((flags & SDL_RESIZABLE) != SDL_RESIZABLE) {
            PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS,
                     Pt_FALSE, Pt_TRUE);
        } else {
            PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS,
                     Pt_FALSE, Pt_TRUE);
            PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE,
                     Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_BORDER);
        }
    } else {
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE,
                 Ph_WM_RENDER_BORDER | Ph_WM_RENDER_TITLE |
                 Ph_WM_RENDER_CLOSE | Ph_WM_RENDER_MENU | Ph_WM_RENDER_MIN);
    }

    if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
        PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);
        PtSetArg(&args[nargs++], Pt_ARG_BASIC_FLAGS, Pt_TRUE,
                 Pt_BASIC_PREVENT_FILL);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE,
                 Ph_WM_FFRONT | Ph_WM_MAX | Ph_WM_TOFRONT | Ph_WM_CONSWITCH);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE,
                 Ph_WM_STATE_ISFRONT | Ph_WM_STATE_ISFOCUS |
                 Ph_WM_STATE_ISALTKEY);
    } else {
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE,
                 Ph_WM_FFRONT | Ph_WM_CONSWITCH);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE,
                 Ph_WM_STATE_ISFRONT);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE,
                 Ph_WM_STATE_ISALTKEY);

        if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
            PtSetArg(&args[nargs++], Pt_ARG_BASIC_FLAGS, Pt_TRUE,
                     Pt_BASIC_PREVENT_FILL);
        } else {
            PtSetArg(&args[nargs++], Pt_ARG_FILL_COLOR, Pg_BLACK, 0);
        }
        if (!currently_maximized) {
            windowpos = SDL_getenv("SDL_VIDEO_WINDOW_POS");
            iscentered = SDL_getenv("SDL_VIDEO_CENTERED");

            if ((iscentered)
                || ((windowpos)
                    && (SDL_strcmp(windowpos, "center") == 0))) {
                PhWindowQueryVisible(Ph_QUERY_CONSOLE, 0, 0, &desktopextent);
                if (desktop_mode.width > w) {
                    pos.x = (desktop_mode.width - w) / 2;
                }
                if (desktop_mode.height > h) {
                    pos.y = (desktop_mode.height - h) / 2;
                }

                pos.x += desktopextent.ul.x;
                pos.y += desktopextent.ul.y;
                PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);
            } else {
                if (windowpos) {
                    if (SDL_sscanf(windowpos, "%d,%d", &x, &y) == 2) {
                        if ((x < desktop_mode.width)
                            && (y < desktop_mode.height)) {
                            PhWindowQueryVisible
                                (Ph_QUERY_CONSOLE, 0, 0, &desktopextent);
                            pos.x = x + desktopextent.ul.x;
                            pos.y = y + desktopextent.ul.y;
                        }
                        PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);
                    }
                }
            }
        }

        /* if window is maximized render it as maximized */
        if (currently_maximized) {
            PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE,
                     Ph_WM_STATE_ISMAX);
        } else {
            PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE,
                     Ph_WM_STATE_ISMAX);
        }

        /* do not grab the keyboard by default */
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE,
                 Ph_WM_STATE_ISALTKEY);

        /* bring the focus to the window */
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE,
                 Ph_WM_STATE_ISFOCUS);

        /* allow to catch hide event */
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE,
                 Ph_WM_HIDE);
        PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
                 Ph_WM_HIDE);
    }

    PtSetResources(window, nargs, args);
    PtRealizeWidget(window);
    PtWindowToFront(window);

#if 0                           /* FIXME */
    PtGetResource(window, Pt_ARG_POS, &olddim, 0);
    fprintf(stderr, "POSITION: %d, %d\n", olddim->w, olddim->h);
#endif

    return 0;
}

static const struct ColourMasks *
ph_GetColourMasks(int bpp)
{
    /* The alpha mask doesn't appears to be needed */
    static const struct ColourMasks phColorMasks[5] = {
        /*  8 bit      */ {0, 0, 0, 0, 8},
        /* 15 bit ARGB */ {0x7C00, 0x03E0, 0x001F, 0x8000, 15},
        /* 16 bit  RGB */ {0xF800, 0x07E0, 0x001F, 0x0000, 16},
        /* 24 bit  RGB */ {0xFF0000, 0x00FF00, 0x0000FF, 0x000000, 24},
        /* 32 bit ARGB */ {0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
                           32},
    };

    switch (bpp) {
    case 8:
        return &phColorMasks[0];
    case 15:
        return &phColorMasks[1];
    case 16:
        return &phColorMasks[2];
    case 24:
        return &phColorMasks[3];
    case 32:
        return &phColorMasks[4];
    }
    return NULL;
}

static int
ph_VideoInit(_THIS, SDL_PixelFormat * vformat)
{
    PgHWCaps_t hwcaps;
    int i;

    window = NULL;
    desktoppal = SDLPH_PAL_NONE;

#if SDL_VIDEO_OPENGL
    oglctx = NULL;
    oglbuffers = NULL;
    oglflags = 0;
    oglbpp = 0;
#endif

    old_video_mode = -1;
    old_refresh_rate = -1;

    if (NULL == (phevent = SDL_malloc(EVENT_SIZE))) {
        SDL_OutOfMemory();
        return -1;
    }
    SDL_memset(phevent, 0x00, EVENT_SIZE);

    window = ph_CreateWindow(this);
    if (window == NULL) {
        SDL_SetError("ph_VideoInit(): Couldn't create video window !\n");
        return -1;
    }

    /* Create the blank cursor */
    SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
                                           (int) BLANK_CWIDTH,
                                           (int) BLANK_CHEIGHT,
                                           (int) BLANK_CHOTX,
                                           (int) BLANK_CHOTY);

    if (SDL_BlankCursor == NULL) {
        return -1;
    }

    if (PgGetGraphicsHWCaps(&hwcaps) < 0) {
        SDL_SetError("ph_VideoInit(): GetGraphicsHWCaps function failed !\n");
        this->FreeWMCursor(this, SDL_BlankCursor);
        return -1;
    }

    if (PgGetVideoModeInfo(hwcaps.current_video_mode, &desktop_mode) < 0) {
        SDL_SetError
            ("ph_VideoInit(): PgGetVideoModeInfo function failed !\n");
        this->FreeWMCursor(this, SDL_BlankCursor);
        return -1;
    }

    /* Determine the current screen size */
    this->info.current_w = desktop_mode.width;
    this->info.current_h = desktop_mode.height;

    /* We need to return BytesPerPixel as it in used by CreateRGBsurface */
    vformat->BitsPerPixel = desktop_mode.bits_per_pixel;
    vformat->BytesPerPixel =
        desktop_mode.bytes_per_scanline / desktop_mode.width;
    desktopbpp = desktop_mode.bits_per_pixel;

    /* save current palette */
    if (desktopbpp == 8) {
        PgGetPalette(savedpal);
        PgGetPalette(syspalph);
    } else {
        for (i = 0; i < _Pg_MAX_PALETTE; i++) {
            savedpal[i] = PgRGB(0, 0, 0);
            syspalph[i] = PgRGB(0, 0, 0);
        }
    }

    currently_fullscreen = 0;
    currently_hided = 0;
    currently_maximized = 0;
    current_overlay = NULL;

    OCImage.direct_context = NULL;
    OCImage.offscreen_context = NULL;
    OCImage.offscreen_backcontext = NULL;
    OCImage.oldDC = NULL;
    OCImage.CurrentFrameData = NULL;
    OCImage.FrameData0 = NULL;
    OCImage.FrameData1 = NULL;
    videomode_emulatemode = 0;

    this->info.wm_available = 1;

    ph_UpdateHWInfo(this);

    return 0;
}

static SDL_Surface *
ph_SetVideoMode(_THIS, SDL_Surface * current, int width, int height, int bpp,
                Uint32 flags)
{
    const struct ColourMasks *mask;

    /* Lock the event thread, in multi-threading environments */
    SDL_Lock_EventThread();

    current->flags = flags;

    /* if we do not have desired fullscreen mode, then fallback into window mode */
    if (((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)
        && (ph_GetVideoMode(width, height, bpp) == 0)) {
        current->flags &= ~SDL_FULLSCREEN;
        current->flags &= ~SDL_NOFRAME;
        current->flags &= ~SDL_RESIZABLE;
    }

    ph_SetupWindow(this, width, height, current->flags);

    mask = ph_GetColourMasks(bpp);
    if (mask != NULL) {
        SDL_ReallocFormat(current, mask->bpp, mask->red, mask->green,
                          mask->blue, 0);
    } else {
        SDL_SetError
            ("ph_SetVideoMode(): desired bpp is not supported by photon !\n");
        return NULL;
    }

    if (current->flags & SDL_INTERNALOPENGL) {
#if !SDL_VIDEO_OPENGL
        /* if no built-in OpenGL support */
        SDL_SetError
            ("ph_SetVideoMode(): no OpenGL support, you need to recompile SDL.\n");
        current->flags &= ~SDL_INTERNALOPENGL;
        return NULL;
#endif /* SDL_VIDEO_OPENGL */
    } else {
        /* Initialize internal variables */
        if ((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
            if (bpp == 8) {
                desktoppal = SDLPH_PAL_SYSTEM;
            }

            current->flags &= ~SDL_RESIZABLE;   /* no resize for Direct Context */
            current->flags |= SDL_HWSURFACE;
        } else {
            /* remove this if we'll have support for the non-fullscreen sw/hw+doublebuf one day */
            current->flags &= ~SDL_DOUBLEBUF;

            /* Use offscreen memory if SDL_HWSURFACE flag is set */
            if ((current->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
                if (desktopbpp != bpp) {
                    current->flags &= ~SDL_HWSURFACE;
                }
            }

            /* using palette emulation code in window mode */
            if (bpp == 8) {
                if (desktopbpp >= 15) {
                    desktoppal = SDLPH_PAL_EMULATE;
                } else {
                    desktoppal = SDLPH_PAL_SYSTEM;
                }
            } else {
                desktoppal = SDLPH_PAL_NONE;
            }
        }
    }

    current->w = width;
    current->h = height;

    if (desktoppal == SDLPH_PAL_SYSTEM) {
        current->flags |= SDL_HWPALETTE;
    }

    /* Must call at least once for setup image planes */
    if (ph_SetupUpdateFunction(this, current, current->flags) == -1) {
        /* Error string was filled in the ph_SetupUpdateFunction() */
        return NULL;
    }

    /* finish window drawing, if we are not in fullscreen, of course */
    if ((current->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
        PtFlush();
    } else {
        PgFlush();
    }

    visualbpp = bpp;

    ph_UpdateHWInfo(this);

    SDL_Unlock_EventThread();

    /* We've done! */
    return (current);
}

static void
ph_VideoQuit(_THIS)
{
    /* restore palette */
    if (desktopbpp == 8) {
        PgSetPalette(syspalph, 0, -1, 0, 0, 0);
        PgSetPalette(savedpal, 0, 0, _Pg_MAX_PALETTE,
                     Pg_PALSET_GLOBAL | Pg_PALSET_FORCE_EXPOSE, 0);
        PgFlush();
    }

    ph_DestroyImage(this, SDL_VideoSurface);

    if (window) {
        PtUnrealizeWidget(window);
        PtDestroyWidget(window);
        window = NULL;
    }

    if (phevent != NULL) {
        SDL_free(phevent);
        phevent = NULL;
    }
}

static int
ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
{
    int i;
    SDL_Rect updaterect;

    updaterect.x = updaterect.y = 0;
    updaterect.w = this->screen->w;
    updaterect.h = this->screen->h;

    /* palette emulation code, using palette of the PhImage_t struct */
    if (desktoppal == SDLPH_PAL_EMULATE) {
        if ((SDL_Image) && (SDL_Image->palette)) {
            for (i = firstcolor; i < firstcolor + ncolors; i++) {
                syspalph[i] =
                    PgRGB(colors[i - firstcolor].r,
                          colors[i - firstcolor].g, colors[i - firstcolor].b);
                SDL_Image->palette[i] = syspalph[i];
            }

            /* image needs to be redrawn */
            this->UpdateRects(this, 1, &updaterect);
        }
    } else {
        if (desktoppal == SDLPH_PAL_SYSTEM) {
            for (i = firstcolor; i < firstcolor + ncolors; i++) {
                syspalph[i] =
                    PgRGB(colors[i - firstcolor].r,
                          colors[i - firstcolor].g, colors[i - firstcolor].b);
            }

            if ((this->screen->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
                /* window mode must use soft palette */
                PgSetPalette(&syspalph[firstcolor], 0, firstcolor,
                             ncolors, Pg_PALSET_GLOBAL, 0);
                /* image needs to be redrawn */
                this->UpdateRects(this, 1, &updaterect);
            } else {
                /* fullscreen mode must use hardware palette */
                PgSetPalette(&syspalph[firstcolor], 0, firstcolor,
                             ncolors, Pg_PALSET_GLOBAL, 0);
            }
        } else {
            /* SDLPH_PAL_NONE do nothing */
        }
    }

    return 1;
}

/* vi: set ts=4 sw=4 expandtab: */