/* 
 *  call-seq:
 *     new(size, depth=0, flags=0)  ->  Surface
 *
 *  Create and initialize a new Surface object. 
 *
 *  A Surface is a grid of image data which you blit (i.e. copy) onto other
 *  Surfaces. Since the Rubygame display is also a Surface (see the Screen 
 *  class), Surfaces can be blit to the screen; this is the most common way
 *  to display images on the screen.
 *
 *  This method may raise SDLError if the SDL video subsystem could
 *  not be initialized for some reason.
 *
 *  This function takes these arguments:
 *  size::  requested surface size; an array of the form [width, height].
 *  depth:: requested color depth (in bits per pixel). If depth is 0 (default),
 *          automatically choose a color depth: either the depth of the Screen
 *          mode (if one has been set), or the greatest color depth available
 *          on the system.
 *  flags:: an Array or Bitwise-OR'd list of zero or more of the following 
 *          flags (located in the Rubygame module, e.g. Rubygame::SWSURFACE).
 *          This argument may be omitted, in which case the Surface 
 *          will be a normal software surface (this is not necessarily a bad
 *          thing).
 *          SWSURFACE::   (default) request a software surface.
 *          HWSURFACE::   request a hardware-accelerated surface (using a 
 *                        graphics card), if available. Creates a software
 *                        surface if hardware surfaces are not available.
 *          SRCCOLORKEY:: request a colorkeyed surface. #set_colorkey will
 *                        also enable colorkey as needed. For a description
 *                        of colorkeys, see #set_colorkey.
 *          SRCALPHA::    request an alpha channel. #set_alpha will
 *                        also enable alpha. as needed. For a description
 *                        of alpha, see #alpha.
 */
VALUE rbgm_surface_new(int argc, VALUE *argv, VALUE class)
{
        VALUE self;
        SDL_Surface *self_surf;
        SDL_PixelFormat* pixformat;
        Uint32 flags, Rmask, Gmask, Bmask, Amask;
        int w, h, depth;
        VALUE vsize, vdepth, vflags;

        rb_scan_args(argc, argv, "12", &vsize, &vdepth, &vflags);

        if( SDL_GetVideoSurface() )
        {
                /* Pixel format is retrieved from the video surface. */
                pixformat = (SDL_GetVideoSurface())->format;
        }
        else
        {
                /* We can only get the system color depth when the video system
                 * has been initialized. */
                if( init_video_system() == 0 )
                {
                        pixformat = SDL_GetVideoInfo()->vfmt;
                }
                else
                {
                        rb_raise(eSDLError,"Could not initialize SDL video subsystem.");
                        return Qnil;
                }
        }

        Rmask = pixformat->Rmask;
        Gmask = pixformat->Gmask;
        Bmask = pixformat->Bmask;
        Amask = pixformat->Amask;

        if( !NIL_P(vdepth) && NUM2INT(vdepth) > 0 )
        {
                /* TODO: We might want to check that the requested depth makes sense. */
                depth = NUM2INT(vdepth);
        }
        else
        {
                depth = pixformat->BitsPerPixel;
        }
                

        /* Get width and height for new surface from vsize */
        vsize = convert_to_array(vsize);

        if(RARRAY_LEN(vsize) >= 2)
        {
                w = NUM2INT(rb_ary_entry(vsize,0));
                h = NUM2INT(rb_ary_entry(vsize,1));
        }
        else
                rb_raise(rb_eArgError,"Array is too short for Surface size (%d for 2)",\
                        RARRAY_LEN(vsize));
        
        flags = collapse_flags(vflags); /* in rubygame_shared */

        /* Finally, we can create the new Surface! Or try, anyway... */
        self_surf = SDL_CreateRGBSurface(flags,w,h,depth,Rmask,Gmask,Bmask,Amask);

        if( self_surf == NULL )
                rb_raise(eSDLError,"Could not create new surface: %s",SDL_GetError());


        /* Wrap the new surface in a crunchy candy VALUE shell. */
        self = Data_Wrap_Struct( cSurface,0,SDL_FreeSurface,self_surf );
        /* The default initialize() does nothing, but may be overridden. */
        rb_obj_call_init(self,argc,argv);
        return self;
}