#include <stdlib.h>

#include "glee.h"
#include "SDL.h"
#include "SDL_opengl.h"
//#include "glib/glib.h"
#include "swfdec/swfdec.h"
#include "swfdec/swfdec_debug.h"
#include "cairo.h"

#define WIN_WIDTH  256
#define WIN_HEIGHT 256

int movie_width;
int movie_height;

void init_gl (void);
void draw_func (unsigned char* surfData, unsigned int   textureId);

int main (int argc, char** argv)
{
   int              window_width = WIN_WIDTH;
   int              window_height = WIN_HEIGHT;
   unsigned int     textureId;
   SDL_Surface*     surfWindow = NULL;
   SDL_Event        event;
   int              keepRunning = 1;
   cairo_surface_t* surf = NULL;
   cairo_t*         cr;
   unsigned char*   surfData;
   SwfdecPlayer *player;
   SwfdecFileLoader *loader;
   SwfdecRenderer *renderer;
   SwfdecURL *url;

   if (argc!=2)
   {
      printf("Usage: swfdectest <movie file>\n");
      exit(1);
   }

   swfdec_init();
   swfdec_debug_set_level(SWFDEC_LEVEL_NONE);

   player=swfdec_player_new(NULL);
   if (player==NULL)
   {
      printf("Failed to create swfdec player\n");
      exit(-1);
   }

   url=swfdec_url_new_from_input(argv[1]);
   if (url==NULL)
   {
      printf("Failed to load movie %s\n", argv[1]);
      exit(-1);
   }
   swfdec_player_set_url(player,url);

   // initialization
   while (!swfdec_player_is_initialized(player))
   {
      long next=swfdec_player_get_next_event(player);
      if (next<0)
      {
         printf("swfdec_get_next_event failed\n");
         exit(-1);
      }
      swfdec_player_advance(player,next);
   }

   // get the width and height of the movie
   swfdec_player_get_default_size(player,
      (guint *)&movie_width, (guint *)&movie_height);

   printf("Movie dimensions %d x %d\n", movie_width, movie_height);

   /* init SDL */
   if ((SDL_Init (SDL_INIT_VIDEO | SDL_INIT_TIMER) == -1))
   {
     printf ("Could not initialize SDL: %s.\n", SDL_GetError ());
     exit (-1);
   }

   /* set window title */
   SDL_WM_SetCaption ("SWFDEC Cairo SDL Test", NULL);

   SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
   SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 6);
   SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
   SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
   SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
   surfWindow = SDL_SetVideoMode (window_width, window_height, 0,
      SDL_OPENGL | SDL_RESIZABLE);

   if (!surfWindow)
   {
      printf ("Couldn't open SDL-window: %s\n", SDL_GetError ());
      exit (-2);
   }

   /* create cairo-surface/context to act as OpenGL-texture source */
   surfData=(unsigned char *)calloc(4*movie_width*movie_height, sizeof(unsigned char));
   if (surfData==NULL)
   {
      printf("Failed to allocate memory for Cairo surface\n");
      exit(-1);
   }
   surf=cairo_image_surface_create_for_data(surfData,
      CAIRO_FORMAT_ARGB32,
      movie_width, movie_height,
      4*movie_width);
   if (cairo_surface_status(surf)!=CAIRO_STATUS_SUCCESS)
   {
      free(surfData);
      printf("Failed to create Cairo surface\n");
      exit(1);
   }
   cr = cairo_create(surf);
   if (cairo_status(cr)!=CAIRO_STATUS_SUCCESS)
   {
      free(surfData);
      printf("Failed to create Cairo context\n");
      exit(1);
   }

   init_gl ();

   while (keepRunning)
   {
      /* get event from queue */
      SDL_PollEvent (&event);
      switch (event.type)
      {
         case SDL_QUIT :
            keepRunning = 0;
         break;

         case SDL_KEYDOWN :
            if (event.key.keysym.sym == SDLK_ESCAPE
             || event.key.keysym.sym == SDLK_q)
               keepRunning = 0;
         break;

         case SDL_VIDEORESIZE :
            window_width = event.resize.w;
            window_height = event.resize.h;
         break;
      }

      // get the next frame of the movie and draw it
      swfdec_player_render(player, cr);
      long next_event=swfdec_player_get_next_event(player);
      swfdec_player_advance(player, next_event);

      draw_func (surfData, textureId);
   }

   /* clear resources before exit */
   glDeleteTextures (1, &textureId);
   free (surfData);
   cairo_destroy (cr);
   SDL_Quit ();
   return 0;
}

void init_gl (void)
{
  glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
  glDisable (GL_DEPTH_TEST);
  glEnable (GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  glEnable (GL_TEXTURE_RECTANGLE_ARB);
}

void draw_func (unsigned char* surfData, unsigned int   textureId)
{
   glMatrixMode (GL_MODELVIEW);
   glLoadIdentity ();
   glClear (GL_COLOR_BUFFER_BIT);
   glPushMatrix ();
   glBindTexture (GL_TEXTURE_RECTANGLE_ARB, textureId);
   glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0,
        GL_RGBA, movie_width, movie_height, 0, GL_BGRA, GL_UNSIGNED_BYTE,
        surfData);

   glColor3f (0.25f, 0.5f, 1.0f);
   glBegin (GL_QUADS);
   glTexCoord2f (0.0f, 0.0f);
   glVertex2f (0.0f, 0.0f);
   glTexCoord2f ((GLfloat) movie_width, 0.0f);
   glVertex2f (1.0f, 0.0f);
   glTexCoord2f ((GLfloat) movie_width, (GLfloat) movie_height);
   glVertex2f (1.0f, 1.0f);
   glTexCoord2f (0.0f, (GLfloat) movie_height);
   glVertex2f (0.0f, 1.0f);
   glEnd ();

   glPopMatrix ();

   SDL_GL_SwapBuffers();
}