#------------------------------------------------------------------------------
# Copyright (c) 2005, Enthought, Inc.
# some parts copyright 2002 by Space Telescope Science Institute
# All rights reserved.
# 
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license.  The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
# Thanks for using Enthought open source!
#------------------------------------------------------------------------------

import copy

from numpy  import alltrue, any, array, asarray, concatenate, float32, uint8, ones, pi, zeros
from OpenGL.GL   import *
from OpenGL.GLU  import *
from pyglet import font, image

import affine
import basecore2d   
from basecore2d import GraphicsContextBase
from constants   import *

#-------------------------------------------------------------------------------
#  Constants:
#-------------------------------------------------------------------------------

DEBUG = False

# There is no implementation of compiled paths for this backend.
CompiledPath = None

#-------------------------------------------------------------------------------
#  Helper functions:
#-------------------------------------------------------------------------------

def gcd ( n, m ):
    """Find the greatest common divisor of integers n and m.
    """
    
    if n == 0: 
       return m
    if m == 0: 
       return n
    return n * m / lcm ( n, m )

def lcm ( n, m ):
    """Return the least common multiple of integers n and m.
    """
    
    # Keep adding to an accumulator until both accumulators are the same:
    an = n
    am = m
    if (an == 0) or (am == 0): 
       return 0
    while an != am:
       if an < am:
          an += n
       else:
          am += m
    return an
    
def mycombine ( coord, vertex, weight ):
    return ( coord[0], coord[1], coord[2] )

#-------------------------------------------------------------------------------
#  'GraphicsContext' class:
#-------------------------------------------------------------------------------

class GraphicsContext(GraphicsContextBase):
    """
    The general call order for a GL graphicscontext is:

    gc = GraphicsContext(size)
    gc.save_state()
    gc.init_gl_viewport()
    ... make drawing calls ...
    gc.restore_state()
    """
    
    def __init__( self, size = ( 500,500 ), dc = None ):
        self._glu_tess_set = 0
        self.size          = size
        GraphicsContextBase.__init__( self )

    def init_gl_viewport(self):
        """ Sets up the viewport and projection matrices. """
        # XXX: This should only be called by Enable when the window resizes 
        glViewport(0, 0, *self.size)
        glMatrixMode(GL_PROJECTION)
        glPushMatrix()
        glLoadIdentity()
        glOrtho(0, self.size[0], 0, self.size[1], 1, -1)
        glMatrixMode(GL_MODELVIEW)
        glPushMatrix()
        glLoadIdentity()

    def save_state(self):
        GraphicsContextBase.save_state(self)
        glMatrixMode(GL_PROJECTION)
        glPushMatrix()
        glMatrixMode(GL_MODELVIEW)
        glPushMatrix()

    def restore_state(self):
        glMatrixMode(GL_PROJECTION)
        glPopMatrix()
        glMatrixMode(GL_MODELVIEW)
        glPopMatrix()
        GraphicsContextBase.restore_state(self)
                
    def begin_page ( self ):
        glClearColor( 1.0, 1.0, 1.0, 0.0 )
        glClear( GL_COLOR_BUFFER_BIT )

    #-------------------------------------------------------------------------
    # Coordinate Transform Matrix Manipulation:
    #-------------------------------------------------------------------------
    
    def get_ctm ( self ):
        """ Return the current coordinate transform matrix.  
        
            Note: untested                                   
        """ 
        glm = glGetDouble( GL_MODELVIEW_MATRIX )
        a   = glm[0,0];  d = glm[1,1]      # x, y diagonal elements
        b   = glm[1,0];  c = glm[0,1]      # x, y rotation
        tx  = glm[0,3]; ty = glm[1,3]      # x, y translation
        return affine.affine_from_values( a, b, c, d, tx, ty )

    #-------------------------------------------------------------------------
    # Handle setting pens and brushes.
    #-------------------------------------------------------------------------

    def device_update_line_state ( self ):
        """ Set the line drawing properties for the graphics context.
        """
        
        #----------------------------------------------------------------
        # Only update if the style has changed.  This and saving a copy
        # of the state (end of if block) may be more costly than just
        # going ahead and setting the line stuff every time...
        #----------------------------------------------------------------
        
        if not basecore2d.line_state_equal( self.last_drawn_line_state,
                                            self.state ):
                                    
            #----------------------------------------------------------------
            # Create a color object based on the current line color            
            #
            # I think this should be moved into each line drawing routine
            # because glColor is used to define both line and fill color.
            # This is unlikely to affect speed.
            #----------------------------------------------------------------
            
            r, g, b, a = self.state.line_color
            glColor( r, g, b, a )
            glLineWidth( self.state.line_width )
            
            #----------------------------------------------------------------
            # ignore cap and join style.  OpenGL doesn't support them as far
            # as I can tell.  The capping can probably be simulated, at least
            # for line ends, by drawing circles or squares on line ends. 
            # I don't see supporting caps on the ends of line dashes.  Also,
            # miters don't appear to have an obvious implementation.
            #----------------------------------------------------------------
            
            #----------------------------------------------------------------
            # dashing
            # not implemented
            #----------------------------------------------------------------
            
            if self.state.is_dashed():
                # line_dash is a (phase,pattern) tuple.
                # phase is ignored by OpenGL.
                factor, pattern = self.line_dash_to_gl()
                glEnable( GL_LINE_STIPPLE )
                glLineStipple( factor, pattern & 0xFFFF ) # <--- TBD: HACK!
            else:
                glDisable( GL_LINE_STIPPLE )
                                        
            #----------------------------------------------------------------
            # update the last_draw_line_state to reflect the new drawing 
            # style.  This may well be more costly than just setting all the
            # styles every time in OpenGL.
            #----------------------------------------------------------------
            
            self.last_drawn_line_state = self.state.copy()
            
    def device_update_fill_state ( self ):
        """ Set the shape filling properties for the graphics context.
            
            This only needs to be drawn before filling a path. 
            See update_line_state for comments.
            
            This uses wxBrush for wxPython.
        """
        
        #----------------------------------------------------------------
        # Test if the last color is the same as the current.  If so, we
        # don't need to mess with the brush.
        #----------------------------------------------------------------

        if any(self.last_drawn_fill_state != self.state.fill_color):
            r, g, b, a = self.state.fill_color
            glColor( r, g, b, a )
            
            #----------------------------------------------------------------
            # Update the last_draw_line_state to reflect this new pen style.
            # A copy is made so that last_drawn_fill_state is independent
            # of changes made to fill_color.
            #----------------------------------------------------------------
            
            self.last_drawn_fill_state = copy.copy( self.state.fill_color )
                        
    def device_update_font_state ( self ):
        """ 
        """
        try:
           font = self.state.font
        except AttributeError:
           self.select_font( SWISS, 18 )
           font = self.state.font
        return ### TBD
        if font.family == ROMAN:
           if font.size <= 17:
              self._glut_font = GLUT_BITMAP_TIMES_ROMAN_10
           else:
              self._glut_font = GLUT_BITMAP_TIMES_ROMAN_24
        else:  # use Helvetica
           if font.size <= 11:
              self._glut_font = GLUT_BITMAP_HELVETICA_10
           elif font.size <= 15:
              self._glut_font = GLUT_BITMAP_HELVETICA_12
           else:
              self._glut_font = GLUT_BITMAP_HELVETICA_18 
        
    def device_fill_points ( self, pts, mode ):
        """
            Needs much work for handling WINDING and ODD EVEN fill rules.
            
            mode 
                Specifies how the subpaths are drawn.  The default is 
                FILL_STROKE.  The following are valid values.  
            
                FILL
                    Paint the path using the nonzero winding rule
                    to determine the regions for painting.
                EOF_FILL 
                    Paint the path using the even-odd fill rule.
                STROKE 
                    Draw the outline of the path with the 
                    current width, end caps, etc settings.
                FILL_STROKE 
                    First fill the path using the nonzero 
                    winding rule, then stroke the path.
                EOF_FILL_STROKE 
                    First fill the path using the even-odd
                    fill method, then stroke the path.                               
        """
        
        if DEBUG: 
           print 'in fill'
        
        if not basecore2d.is_fully_transparent( self.state.fill_color ):          
            #print 'fill:'
            #glm = glGetInteger(GL_MODELVIEW_MATRIX)
            #print glm
            self.gl_render_points( pts, self.state.fill_color, 
                                   polygon = 1, fill = 1, mode = mode )

    def device_stroke_points ( self, pts, mode ):
        """ Draw a set of connected points using the current stroke settings.
        
            mode 
                Specifies how the subpaths are drawn.  The default is 
                FILL_STROKE.  The following are valid values.  
            
                FILL
                    Paint the path using the nonzero winding rule
                    to determine the regions for painting.
                EOF_FILL 
                    Paint the path using the even-odd fill rule.
                STROKE 
                    Draw the outline of the path with the 
                    current width, end caps, etc settings.
                FILL_STROKE 
                    First fill the path using the nonzero 
                    winding rule, then stroke the path.
                EOF_FILL_STROKE 
                    First fill the path using the even-odd
                    fill method, then stroke the path.                               
            
        """

        #--------------------------------------------------------------------
        # Only draw lines if the current settings are not fully transparent.
        # and the drawing mode is a "stroke" mode
        #-------------------------------------------------------------------- 
              
        if not basecore2d.is_fully_transparent( self.state.line_color ):

           #----------------------------------------------------------------
           # We do not try to deal with scaled line width yet:
           #----------------------------------------------------------------
           
           pass            

           #----------------------------------------------------------------
           # This if/then solves line ending problems in wxPython so that
           # the last two points are connected in the drawing.  I think
           # it may do the same here, but I'm not entirely sure.
           #----------------------------------------------------------------
           
           if alltrue( pts[0] == pts[-1] ):
              self.gl_render_points( pts, self.state.line_color, 
                                     polygon = 1, fill = 0, mode = mode ) 
           else:
              self.gl_render_points( pts, self.state.line_color, 
                                     polygon = 0, fill = 0, mode = mode )
                
    def device_draw_rect ( self, x, y, sx, sy, mode = FILL ):
        """ Not often used -- calls generally go through draw_points.
            Is mode needed?
            
            Dead code -- at least for now.
        """
        
        pts = array( ( (x,y), (x,y + sy), (x + sx, y + sy),(x + sx, y) ), float)
        self.gl_render_points( pts, self.state.fill_color, # Fill 
                               polygon = 1, fill = 1, mode = mode, convex = 1 )
        self.gl_render_points( pts, self.state. line_color, # Outline  
                               polygon = 1, fill = 0, mode = mode, convex = 1 )

    def gl_render_points ( self, pts, color, polygon = 0, fill = 0, mode = FILL,
                           convex = 0 ):
        r, g, b, a = color
        glColor( r, g, b, a )

        # Needed to correctly fill non-convex polygons:
        if polygon and fill and not convex:  
            self.gl_tesselate_polygon( pts, mode )
            return
            
        if polygon:
           poly_mode = GL_POLYGON
        else:
           poly_mode = GL_LINE_STRIP
        
        if fill:
           fill_mode = GL_FILL
        else:   
           fill_mode = GL_LINE            
        
        if a == 1.:
           glDisable(GL_BLEND)
        else:
           glEnable( GL_BLEND )
           glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA )

        glPolygonMode( GL_FRONT_AND_BACK, fill_mode )
        glVertexPointerd( pts )
        glEnableClientState( GL_VERTEX_ARRAY )
        glDrawArrays( poly_mode, 0, len( pts ) )
        glDisableClientState( GL_VERTEX_ARRAY )

        # Shouldn't be necessary:
        glDisable( GL_BLEND )

    def gl_render_points_set( self, pts_set, fill_color, stroke_color, 
                              polygon = 0, fill = 1, stroke = 1 ):        
        fr, fg, fb, fa = fill_color
        sr, sg, sb, sa = stroke_color
        pts_set        = asarray( pts_set )
        len_pts        = pts_set.shape[1]

        if polygon:
           poly_mode = GL_POLYGON
        else:
           poly_mode = GL_LINE_STRIP
        
        for pts in pts_set:    
            glVertexPointerd( pts )
            glEnableClientState( GL_VERTEX_ARRAY )
            if fill:
               glColor( fr, fa, fb, fa )
               glPolygonMode( GL_FRONT_AND_BACK, GL_FILL )
               glDrawArrays( poly_mode, 0, len_pts )
            if stroke:
               glColor( sr, sg, sb, sa )
               glPolygonMode( GL_FRONT_AND_BACK, GL_LINE )
               glDrawArrays( poly_mode, 0, len_pts )
            glDisableClientState( GL_VERTEX_ARRAY )

    def gl_tesselate_polygon ( self, pts, mode ):
        if not self._glu_tess_set:
            self.setup_glu_tess()

        if mode in [EOF_FILL, EOF_FILL_STROKE]:
            gluTessProperty( self._glu_tess, GLU_TESS_WINDING_RULE, 
                            GLU_TESS_WINDING_ODD )
        else:
            gluTessProperty( self._glu_tess, GLU_TESS_WINDING_RULE, 
                            GLU_TESS_WINDING_NONZERO )

        # Draw the points (need only a single contour)
        # This may need to go into C for speed.
        glPolygonMode( GL_FRONT_AND_BACK, GL_FILL )        
        gluTessBeginPolygon( self._glu_tess, None )
        
        # Reported to be 10% when all points lie on x,y plane. Look here:
        # http://oss.sgi.com/cgi-bin/cvsweb.cgi/projects/ogl-sample/main/gfx/lib/glu/
        #        libtess/README?rev=1.1&content-type=text/x-cvsweb-markup        
        gluTessNormal( self._glu_tess, 0, 0, 0 )
        gluTessBeginContour( self._glu_tess )
        for pt in pts:
            thispt = array( [ pt[0], pt[1], 0 ] )
            gluTessVertex( self._glu_tess, thispt, thispt )
        gluTessEndContour( self._glu_tess )
        gluTessEndPolygon( self._glu_tess )

    def setup_glu_tess ( self ):
        self._glu_tess = gluNewTess()
        gluTessCallback( self._glu_tess, GLU_TESS_BEGIN,  glBegin )
        gluTessCallback( self._glu_tess, GLU_TESS_END,    glEnd )
        gluTessCallback( self._glu_tess, GLU_TESS_VERTEX, glVertex )
                        
        gluTessCallback( self._glu_tess, GLU_TESS_COMBINE, mycombine )
        gluTessProperty( self._glu_tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE )
        self._glu_tess_set = 1                   
        
    def device_prepare_device_ctm  (self ):
        sz = self.size
        glMatrixMode( GL_PROJECTION )
        glLoadIdentity()
        gluOrtho2D( 0.0, sz[0], 0.0, sz[1] )
        glMatrixMode( GL_MODELVIEW )
        glLoadIdentity()
        if  DEBUG: print "ctm prepared", self.gl_ctm();
                
    def device_transform_device_ctm ( self, func, args ):
        """ Default implementation for handling scaling matrices.  
        
            Many implementations will just use this function.  Others, like
            OpenGL, can benefit from overriding the method and using 
            hardware acceleration.            
        """
        if func == SCALE_CTM:
           glScalef( args[0], args[1], 1 )
        elif func == ROTATE_CTM:
           glRotate( args[0] * 180 / pi, 0, 0, 1 )        
        elif func == TRANSLATE_CTM:
           if DEBUG: print 'translate', args[0], args[1]
           glTranslate( args[0], args[1], 0 )
           if DEBUG: print 'after translate', self.gl_ctm(),'\n'
        elif func == CONCAT_CTM:
           if DEBUG: print 'concat'
           glm = self.affine_to_gl( args[0] )
           glMultMatrixf( glm )
        elif func == LOAD_CTM:
           if DEBUG: print 'load', args[0]
           glm = self.affine_to_gl( args[0] )
           glLoadMatrixf( glm )
           if DEBUG: print 'after load', self.gl_ctm(),'\n'

    def line_dash_to_gl ( self ):
        phase, pattern = self.state.line_dash
    
        # convert this to factor, gl_pattern.  This is only possible exactly if the sum of
        #  the integers in pattern is 2, 4, 8, or 16.  Otherwise, only an approximation is
        #  possible.  The approximation selected is to extend the given pattern to a multiple
        #  of 16, phase-shift the full pattern, then sample the bits to give the 16 bits
        #  available for the gl_pattern.   The bits are represented in a byte array of 1s and 0s.
        #  factor is set to the greatest common divisor of pattern and phase.  The pattern and
        #  phase are then scaled by this factor.
        L = sum( pattern )

        # Handle case where phase >= L:
        if phase >= L:
           phase = phase % L

        # Compute any factor to use:
        factor = gcd( phase, pattern[0] )
        for k in range( 1, len( pattern ) ):
            factor = gcd( factor, pattern[k] )
        if factor > 1:
           phase   /= factor
           pattern  = pattern.copy() / factor
           L       /= factor

        D    = lcm( L, 16 )
        x, n = D / L, D / 16
        
        # Make a bit-field xL long:
        bits = ones( L, 'b' )
        
        # Fill the bit-field with the given pattern:
        start = 0
        k     = 0
        for num in pattern:
            # Odd elements zero-these out in the bit-field:
            if k % 2:  
               bits[ int( start) : int( start + num ) ] = 0 # TBD: HACK
            start += num
            k     += 1

        bigbits = bits.copy()
        for k in range( 1, x ):
            bigbits = concatenate( ( bigbits, bits ) )
        if phase > 0:
           bigbits = concatenate( (bigbits[phase:], bigbits[:phase] ) )

        gl_bits = bigbits[:: int( n ) ]  # TBD: HACK take every nth sample.
    
        # Just a sanity check:
        assert(len(gl_bits)==16)   
        
        # Convert to integer (place last bit in least significant bit):
        gl_pattern = 0
        for k in range( 15, -1, -1 ):
            gl_pattern <<= 1
            gl_pattern  += gl_bits[k]

        return ( factor, gl_pattern )

    def affine_to_gl ( self, mat, load = 0 ):
        a, b, c, d, tx, ty = affine.affine_params( mat )
        glm = zeros( (4,4), float32 )
        
        # a,b,c,d,tx,ty are transposed from PDF:
        glm[0,0] = a;  glm[0,1] = b       
        glm[1,0] = c;  glm[1,1] = d       
        glm[3,0] = tx; glm[3,1] = ty      # x, y translation
        glm[2,2] = 1;  glm[3,3] = 1       # z, w diagonal elements        
        return glm

    def gl_ctm ( self ):
        return glGetFloat( GL_MODELVIEW_MATRIX )
        
    def x_device_show_text ( self, text ):
        """ Insert text at the current text position
        """
        self.device_update_font_state()
        tx, ty     = self.get_text_position()
        r, g, b, a = self.state.fill_color
        glColor3( r, g, b )
        glRasterPos( tx, ty )
        self.device_draw_rect( tx, ty, 60, 24 ) # TBD: TEMPORARY
        return ### TBD
        for char in text:
            glutBitmapCharacter( self._glut_font, ord( char ) )

    def device_draw_glyphs ( self, glyphs, tx, ty ):
        dy, dx      = glyphs.image.shape
        img         = zeros( ( dy, dx, 4 ), uint8 )
        r, g, b, a  = self.state.fill_color
        img[:,:,:3] = array( ( int( 255.0 * r ), 
                               int( 255.0 * g ), 
                               int( 255.0 * b ) ), uint8 )
        img[:,:,3]  = glyphs.image.astype( uint8 )[::-1]
        glRasterPos( tx + glyphs.bbox[0], ty + glyphs.bbox[1] )
        glEnable( GL_BLEND )
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA )
        glDrawPixels( dx, dy, GL_RGBA, GL_UNSIGNED_BYTE, img.tostring() )
        glDisable( GL_BLEND )

    def device_set_clipping_path(self,x,y,width,height):
        glScissor( x, y, width, height )
        glEnable( GL_SCISSOR_TEST )
        return
        
    def device_destroy_clipping_path(self):
        glDisable( GL_SCISSOR_TEST )
        return    

    #------------------------------------------------------------------------
    # Overloaded
    #------------------------------------------------------------------------
    #def rect(self,x,y,sx,sy):
    #    """ Add a rectangle as a new subpath.
    #    """
    #    self._new_subpath()
    #    self.active_subpath.append( (RECT,array((x,y,sx,sy),float64)) )
            
    def flush ( self ):
        glFlush()

    def synchronize ( self ):
        # This is taking a whale of a long time (.15 sec on 1000x1000 window)
        # what gives?
        #glutSwapBuffers()
        pass

    #----------------------------------------------------------
    # Misc methods
    # TODO: Fix these / figure these out
    #----------------------------------------------------------

    def clear(self, *args):
        """ Clears the screen to the given RGB or RGBA colors:

            clear(r, g, b)
            clear(r, g, b, a)
            clear( (r,g,b) )
            clear( (r,g,b,a) )

            If no color is given, then clears to the current graphics
            state's fill_color.
        """
        if len(args) == 0:
            color = self.state.fill_color
        elif len(args) == 1:
            args = args[0]

        if len(args) == 3:
            color = args + (1,)
        else:
            color = args

        glClearColor(*color)
        glClear(GL_COLOR_BUFFER_BIT)
        


class Canvas(object):
    pass

def font_metrics_provider(*args, **kw):
    pass