/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@devolution.com
*/

#ifdef SAVE_RCSID
static char rcsid =
 "@(#) $Id$";
#endif

#include <stdlib.h>
#include <Ph.h>
#include <photon/Pg.h>

#include "SDL_error.h"
#include "SDL_endian.h"
#include "SDL_ph_image_c.h"

//printf("%s:%s:%d\n", __FILE__, __PRETTY_FUNCTION__, __LINE__ );

/* Various screen update functions available */
//static void ph_NormalUpdate(_THIS, int numrects, SDL_Rect *rects);
//static void ph_DummyUpdate(_THIS, int numrects, SDL_Rect *rects);

int ph_SetupImage(_THIS, SDL_Surface *screen)
{
	int type = 0;

	/* Determine image type */
	switch(screen->format->BitsPerPixel)
	{
		case 8:{
			type = Pg_IMAGE_PALETTE_BYTE;
		}
		break;
		case 15:{
			type = Pg_IMAGE_DIRECT_555; 
		}
		break;
		case 16:{
			type = Pg_IMAGE_DIRECT_565; 
		}
		break;

		case 24:{
			type = Pg_IMAGE_DIRECT_888;
		}
		break;
		
		case 32:{
			type = Pg_IMAGE_DIRECT_8888;
		}
		break;
		default:{
		/* should never get here */
			fprintf(stderr,"error: unsupported bbp = %d\n",
					screen->format->BitsPerPixel);
			return -1;
		}
		break;
	}

	//using shared memory for speed (set last param to 1)
	if ((SDL_Image = PhCreateImage( NULL, screen->w, screen->h, type, NULL, 0, 1 )) 
		== NULL)
	{
		fprintf(stderr,"error: PhCreateImage failed.\n");
		return -1;
	}

	screen->pixels = SDL_Image->image;
	
	this->UpdateRects = ph_NormalUpdate;

	return 0;
}

int ph_SetupOCImage(_THIS, SDL_Surface *screen) //Offscreen context
{
	int type = 0;

	/* Determine image type */
	switch(screen->format->BitsPerPixel)
	{
		case 8:{
			type = Pg_IMAGE_PALETTE_BYTE;
		}
		break;
		case 15:{
			type = Pg_IMAGE_DIRECT_555; 
		}
		break;
		case 16:{
			type = Pg_IMAGE_DIRECT_565; 
		}
		break;

		case 24:{
			type = Pg_IMAGE_DIRECT_888;
		}
		break;
		
		case 32:{
			type = Pg_IMAGE_DIRECT_8888;
		}
		break;
		default:{
		/* should never get here */
			fprintf(stderr,"error: unsupported bbp = %d\n",
					screen->format->BitsPerPixel);
			return -1;
		}
		break;
	}

		OCImage.FrameData0 = (FRAMEDATA *) malloc((size_t)(sizeof( FRAMEDATA)));
		OCImage.FrameData1 = (FRAMEDATA *) malloc((size_t)(sizeof( FRAMEDATA)));

	if(OCImage.direct_context == NULL)
	  OCImage.direct_context = PdCreateDirectContext();

	  OCImage.offscreen_context = PdCreateOffscreenContext(0,screen->w,screen->h, Pg_OSC_MEM_PAGE_ALIGN);	
				
		if (OCImage.offscreen_context == NULL)
		{
			printf("PdCreateOffscreenContext  failed\n");
			return -1;
		}

		OCImage.Stride = OCImage.offscreen_context->pitch;	

      if (OCImage.flags & SDL_DOUBLEBUF)
      			printf("hardware flag for doublebuf offscreen context\n");

			
			OCImage.dc_ptr.ptr8 = (unsigned char *) PdGetOffscreenContextPtr(OCImage.offscreen_context);
			
			OCImage.CurrentFrameData = OCImage.FrameData0;
			OCImage.CurrentFrameData->Y = OCImage.dc_ptr.ptr8;
			OCImage.CurrentFrameData->U = NULL;
			OCImage.CurrentFrameData->V = NULL;
			OCImage.current = 0;
	
			if(OCImage.dc_ptr.ptr8 == NULL)
			{
 				printf("PdGetOffscreenContextPtr failed\n");
 				return -1;
			}
			
			PhDCSetCurrent(OCImage.offscreen_context);

			screen->pixels = OCImage.CurrentFrameData->Y;
	
			this->UpdateRects = ph_OCUpdate;

	return 0;
}


void ph_DestroyImage(_THIS, SDL_Surface *screen)
{


   if(SDL_Image == NULL)
     return;

	 if (OCImage.offscreen_context != NULL)
	{
			
			PhDCRelease(OCImage.offscreen_context);
			OCImage.offscreen_context = NULL;
			free(OCImage.FrameData0);
			OCImage.FrameData0 = NULL;
			free(OCImage.FrameData1);
			OCImage.FrameData1 = NULL;
	}

	if (SDL_Image->image)
	{
		//free(SDL_Image->image);
		//SDL_Image->image = NULL;
		PhReleaseImage(SDL_Image);
		SDL_Image = NULL;
	}

	if ( screen ) {
    	screen->pixels = NULL;
	}
	
	SDL_Image = NULL;
}

int ph_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)
{
  
    ph_DestroyImage(this, screen);
    
    if(  flags & SDL_HWSURFACE)
    {
       OCImage.flags = flags;  //needed for SDL_DOUBLEBUF check
       return ph_SetupOCImage(this,screen);
    }
    else if(flags & SDL_OPENGL) /* No image when using GL */
    {
       return 0;
    } 
    else
    {
        return ph_SetupImage(this, screen);
    }      

}

int ph_AllocHWSurface(_THIS, SDL_Surface *surface)
{

        return(-1);
}

void ph_FreeHWSurface(_THIS, SDL_Surface *surface)
{

        return;
}

int ph_FlipHWSurface(_THIS, SDL_Surface *surface)
{

        return(0);
}

int ph_LockHWSurface(_THIS, SDL_Surface *surface)
{

        if ( (surface == SDL_VideoSurface) && blit_queued ) {
//                XSync(GFX_Display, False);
				PgFlush();
                blit_queued = 0;
        }
        return(0);
}

void ph_UnlockHWSurface(_THIS, SDL_Surface *surface)
{

        return;
}

static PhPoint_t ph_pos;
static PhRect_t ph_rect;
static int i;

void ph_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
{

    for ( i=0; i<numrects; ++i ) 
	{
    	if ( rects[i].w == 0 ) { /* Clipped? */
                continue;
        }

		ph_pos.x = rects[i].x;
		ph_pos.y = rects[i].y;
		ph_rect.ul.x = rects[i].x;
		ph_rect.ul.y = rects[i].y;
		ph_rect.lr.x = rects[i].x + rects[i].w;
		ph_rect.lr.y = rects[i].y + rects[i].h;

		if (PgDrawPhImageRectmx( &ph_pos, SDL_Image, &ph_rect, 0 ) < 0)
		{
			fprintf(stderr,"error: PgDrawPhImageRectmx failed.\n");
		}
	}
    if (PgFlush() < 0)
	{
    	fprintf(stderr,"error: PgFlush failed.\n");
    }
}
void ph_OCUpdate(_THIS, int numrects, SDL_Rect *rects)
{
	PhPoint_t zero = {0};
	PhRect_t src_rect;
	PhRect_t dest_rect;

	if(OCImage.direct_context == NULL)
	 {
	    return;
	 }   
	   		
	  PgSetRegion(PtWidgetRid(window));
	  PgSetClipping(0,NULL);
	  PgWaitHWIdle();
 		

    for ( i=0; i<numrects; ++i ) 
	{
    	if ( rects[i].w == 0 ) { /* Clipped? */
                continue;
        }

			src_rect.ul.x=rects[i].x;
			src_rect.ul.y=rects[i].y;
			dest_rect.ul.x=rects[i].x;
			dest_rect.ul.y=rects[i].y;
			
			dest_rect.lr.x=src_rect.lr.x= rects[i].x +rects[i].w;
			dest_rect.lr.y=src_rect.lr.y= rects[i].y +rects[i].h;
		
			zero.x = zero.y = 0;
	   		PgSetTranslation (&zero, 0);
	       PgSetRegion(PtWidgetRid(window));
			PgSetClipping(0,NULL);
 			PgContextBlitArea(OCImage.offscreen_context, (PhArea_t *)(&src_rect), NULL, (PhArea_t *)(&dest_rect));
 			
	}
    if (PgFlush() < 0)
	{
    	fprintf(stderr,"error: PgFlush failed.\n");
    }
    
 //later used to toggling double buffer   
    if(OCImage.current == 0)
	{
		OCImage.CurrentFrameData = OCImage.FrameData0;
	}
	else
	{
		OCImage.CurrentFrameData = OCImage.FrameData1;
	}
}