#!/usr/bin/python

import cluttergtk   # must be the first to be imported
import clutter
import pygtk
pygtk.require("2.0")
import gtk
import gobject
import glib
import time
import cairo
import pango
import pangocairo
import rsvg
import sys
import math
from math import sqrt

import random


class DiceRollView(clutter.Group):
    """
    Does dice-rolling animation and display of
    successes.
    """
    DICE_ROLLED_HEIGHT = 50
    DICE_UNROLLED_HEIGHT = 50
    DICE_SIZE = 40
    def __init__(self, stage):
        clutter.Group.__init__(self)

        self.set_reactive(True)     #needed to recieve clicks!
        self.stage = stage
        self.stage.add(self)

        self.be_behind = []     #a list of actors that animations should stay behind; this is used for 'real_roll' values
        self.rollable_area = (0,0,1,1)      #bounding box that designates where popup numbers may appear
        self.completed_rolls = 0

        self.set_size(500,500)
        self.w,self.h = self.get_size()

        self.background = self._create_background()
        self.add(self.background)

        self.connect("motion-event", self.on_mouse_move)
        self.connect("button-press-event", self.on_mouse_press)

    def on_mouse_press(self, actor, event):
        self.animate_popout_real_roll(self._make_number( "1234567890" ))
    def on_mouse_move(self, actor, event):
        self.animate_popout(self._make_number( 1230 ))
        pass

    def _get_next_completed_roll_pos_and_size(self):
        """
        returns a the coordinates of the next empty spot
        in the completed rolls queue and the size that the die
        should be.
        """
        return (self.completed_rolls*self.DICE_SIZE, 0), self.DICE_SIZE
    def add_completed_roll(self, actor):
        """
        move actor to the completed rolls queue
        """
        def do_shrink(*x):
            #anim2 = actor.animate(clutter.LINEAR, 400, 'scale-x', scale_factor, 'scale-y', scale_factor)
            anim2 = actor.animate(clutter.LINEAR, 400, 'scale-x', 1)
            anim2.connect_after('completed', do_last)
        def do_last(*x):
            actor.raise_top()
            print actor.get_opacity(), actor.get_color(), actor.get_animation()
            print actor
            anim2 = actor.animate(clutter.LINEAR, 1000, 'scale-x', .5)
            anim2.connect_after("completed", do_last_last)
        def do_last_last(*x):
            actor.animate(clutter.LINEAR, 1000, 'scale-x', 1)
            pass

        pos,target_size = self._get_next_completed_roll_pos_and_size()
        scale_factor = float(target_size)/max(actor.get_size())
        print scale_factor
        anim1 = actor.animate(clutter.LINEAR, 400, 'scale-x', 1, 'x', pos[0], 'y', pos[1] )
        anim1.connect_after('completed', do_shrink)
        self.completed_rolls += 1

    def animate_popout_real_roll(self, actor):
        """
        animates actor to 'pop out' of the screen
        with a pretty effect and then moves
        the actor into the roll queue
        """
        def do_glow(*x):
            actor_clone.set_position( self.w/2, self.h/2 )
            actor_clone.set_opacity(0)
            actor_clone.show()
            anim2 = actor_clone.animate(clutter.EASE_OUT_QUAD, 400, "opacity", 200,
                "scale-x", 2, "scale-y", 2,
                "fixed::scale-center-x", actor_clone.get_width()/2, "fixed::scale-center-y", actor_clone.get_height()/2,
                "x", end_pos[0], "y", end_pos[1])
            anim2.connect_after("completed", do_fade_out)
        def do_fade_out(*x):
            anim3 = actor_clone.animate(clutter.EASE_OUT_QUAD, 400, "opacity", 0)
            anim4 = actor.animate(clutter.EASE_OUT_QUAD, 400,
                "color", clutter.Color(255,0,0,255))
            anim4.connect_after("completed", do_finish_actor)
            anim3.connect_after("completed", do_finish_clone)
        def do_finish_actor(*x):
            self.add_completed_roll(actor)
        def do_finish_clone(*x):
            self.remove(actor_clone)

        self.be_behind.append(actor)

        actor.set_position( self.w/2, self.h/2 )
        actor.set_scale(.1,.1)

        end_pos = (random.randrange(self.rollable_area[0],self.rollable_area[2]-actor.get_width()), random.randrange(self.rollable_area[1],self.rollable_area[3]-actor.get_height()))
        actor_clone = clutter.Clone(actor)
        actor_clone.hide()
        actor_clone.set_position(*end_pos)
        self.add(actor_clone)
        self.add(actor)
        anim1 = actor.animate(clutter.EASE_OUT_CUBIC, 250,
            "x", end_pos[0], "y", end_pos[1],
            "scale-x", 1, "scale-y", 1)
            #"color", clutter.Color(255,0,0,255))
        anim1.connect_after("completed", do_fade_out)
        #do_glow()

    def animate_popout(self, actor):
        """
        animates actor to 'pop out' of the screen
        with a pretty effect
        """
        def do_glow(*x):
            actor_clone.set_position( self.w/2, self.h/2 )
            actor_clone.set_opacity(0)
            actor_clone.show()
            anim2 = actor_clone.animate(clutter.EASE_OUT_QUAD, 400, "opacity", 200,
                "scale-x", 2, "scale-y", 2,
                "fixed::scale-center-x", actor_clone.get_width()/2, "fixed::scale-center-y", actor_clone.get_height()/2,
                "x", end_pos[0], "y", end_pos[1])
            anim2.connect_after("completed", do_fade_out)
        def do_fade_out(*x):
            anim3 = actor_clone.animate(clutter.EASE_OUT_QUAD, 400, "opacity", 0)
            anim4 = actor.animate(clutter.EASE_OUT_QUAD, 400, "opacity", 0)
            anim4.connect_after("completed", do_finish_actor)
            anim3.connect_after("completed", do_finish_clone)
        def do_finish_actor(*x):
            self.remove(actor)
        def do_finish_clone(*x):
            self.remove(actor_clone)

        actor.set_position( self.w/2, self.h/2 )
        actor.set_scale(.1,.1)

        end_pos = (random.randrange(self.rollable_area[0],self.rollable_area[2]-actor.get_width()), random.randrange(self.rollable_area[1],self.rollable_area[3]-actor.get_height()))
        actor_clone = clutter.Clone(actor)
        actor_clone.hide()
        actor_clone.set_position(*end_pos)
        self.add(actor_clone)
        self.add(actor)
        for above in self.be_behind:
            above.raise_top()

        anim1 = actor.animate(clutter.EASE_OUT_CUBIC, 250,
            "x", end_pos[0], "y", end_pos[1],
            "scale-x", 1, "scale-y", 1)
        do_glow()

    def _make_number(self, num):
        """
        makes a new actor that displays the number num
        """
        num = str(num)

        ret = clutter.Text()
        ret.set_color( clutter.color_from_string("white") )
        ret.set_text( num )
        ret.set_font_name( "Serif Bold 50" )

        return ret

    def _create_background(self):
        PADDING = 20
        RADIUS = 20
        new_w,new_h = int(self.stage.get_width()),int(self.stage.get_height())

        back =  clutter.CairoTexture(new_w,new_h)
        cr = back.cairo_create()
        cr.set_source_rgb(.4,.4,.4)
        cr.paint()

        #figure out where we should draw this box
        draw_area = (PADDING, self.DICE_ROLLED_HEIGHT+PADDING, self.w-2*PADDING, self.h-self.DICE_ROLLED_HEIGHT-self.DICE_UNROLLED_HEIGHT -2*PADDING)
        rollable_inset = (sqrt(2)-1)*RADIUS
        self.rollable_area = [int(i) for i in (draw_area[0] + rollable_inset, draw_area[1] + rollable_inset, draw_area[0]+draw_area[2]-rollable_inset, draw_area[1]+draw_area[3]-rollable_inset)]
        self.draw_box_with_rounded_corners(cr, draw_area[0], draw_area[1], draw_area[2], draw_area[3], RADIUS, (0.95*.1, 0.75*.1, 0.5*.1, 1))
        del cr

        return back
    def draw_box_with_rounded_corners(self, ctx, x, y, w, h, rad=10, col_fill=(0.95, 0.75, 0.5, 0.3), col_border=(0.9, 0.5, 0.1, .5)):
        ctx.move_to(x+rad,y)
        ctx.rel_line_to( w - 2*rad,0)
        ctx.rel_curve_to( 0, 0, rad, 0, rad, rad)
        ctx.rel_line_to( 0,h - 2*rad)
        ctx.rel_curve_to( 0, 0, 0, rad, -rad, rad)
        ctx.rel_line_to( -(w - 2*rad),0)
        ctx.rel_curve_to( 0, 0, -rad, 0, -rad, -rad)
        ctx.rel_line_to( 0,-(h - 2*rad))
        ctx.rel_curve_to( 0, 0, 0, -rad, rad, -rad)
        ctx.close_path()

        ctx.set_source_rgba(*col_fill)
        ctx.fill_preserve()
        ctx.set_source_rgba(*col_border)
        ctx.stroke()

    def stage_resized(self):
        """
        resize ourselves and redraw the background, etc.
        """
        self.set_size( *self.stage.get_size() )
        self.w,self.h = self.get_size()

        new_back = self._create_background()
        self.add(new_back)
        new_back.lower_bottom()
        self.remove(self.background)
        self.background = new_back



class MainWindow(object):
    def __init__(self):
        builder = gtk.Builder()
        builder.add_from_file("charactersettings.ui")

        builder.get_object("main_window").connect("destroy-event", gtk.main_quit)
        builder.get_object("main_window").connect("delete-event", gtk.main_quit)

        #get us a clutter stage and put it in the vbox
        self.vbox_clutter = builder.get_object("vbox_clutter")
        embed = cluttergtk.Embed()
        self.vbox_clutter.pack_start(embed, True, True, 0)
        embed.set_size_request(640,492)
        #realizing the embed allows us to get the stage
        embed.realize()

        stage = embed.get_stage()
        stage.set_color(clutter.color_from_string('DarkBlue'))

        #we need depth sorting so we can flip cards over and see their backside
        #clutter.cogl.set_depth_test_enabled(True)
        #clutter.cogl.set_backface_culling_enabled(True)
        #clutter.cogl.perspective(10,1,-1,1000)
        self.inven = DiceRollView(stage)


        stage.connect('notify::allocation', self.on_stage_allocate)
        embed.show()

    def on_stage_allocate (self, actor, pspec):
        self.inven.stage_resized()
        pass

    def start(self):
        gtk.main()






if __name__ == "__main__":
    app = MainWindow()
    app.start()