#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import clutter
import logging

from math import ceil
from time import time


logging.basicConfig()

log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)


class Slider(object):
    def __init__(self, bg, container, width=None, height=None,
                 stepx=None, stepy=None,
                 x=0, y=0):
        self.container = container
        self.pressed = False
        self.x = x
        self.y = y

        if stepx:
            width = int(ceil(width / float(stepx)) * stepx)
        if stepy:
            height = int(ceil(height / float(stepy)) * stepy)

        self.width = width
        self.height = height
        self.stepx = stepx
        self.stepy = stepy

        self.timeline = clutter.Timeline(duration=True)
        self.timeline.set_duration(200)
        self.timeline.set_loop(False)

        alpha = clutter.Alpha(self.timeline, clutter.sine_inc_func)
        self.behaviour = clutter.BehaviourPath(alpha)
        self.behaviour.apply(container)

        w, h = bg.get_size()
        if width:
            self.minleft = w - width
            self.maxright = 0
        if height:
            self.mintop = h - height
            self.maxbottom = 0

        bg.connect("button-press-event", self.press, self)
        bg.connect("button-release-event", self.release, self)
        bg.connect("motion-event", self.motion, self)

    @staticmethod
    def leave(actor, event, self):
        log.info("left")

    @staticmethod
    def press(actor, event, self):
        self.pressed = True
        if self.width:
            self._x = event.x
        if self.height:
            self._y = event.y
        self._time = time()

    @staticmethod
    def release(actor, event, self):
        self.pressed = False
        x, y = 0, 0
        diffx, diffy = 0, 0

        if self.width:
            diffx = event.x - self._x
        if self.height:
            diffy = event.y - self._y
            diffy = event.y - self._y

        delta = time() - self._time
        dist = (diffx**2 + diffy**2)**.5
        speed = int((dist/float(delta)) / 1000)

        if diffx:
            self.x += diffx
            x = self.x + diffx*speed
            x = max(self.minleft, min(self.maxright, x))
        if diffy:
            self.y += diffy
            y = self.y + diffy*speed
            y = max(self.mintop, min(self.maxbottom, y))

        if self.stepx:
            x = int(round(x / float(self.stepx)) * self.stepx)
        if self.stepy:
            y = int(round(y / float(self.stepy)) * self.stepy)
            pass

        self.container.set_position(self.x, self.y)

        if self.x != x or self.y != y:
            self.behaviour.clear()
            self.behaviour.append_knots((self.x, self.y))
            self.behaviour.append_knots((x, y))
            self.timeline.start()

            self.x = x
            self.y = y

    @staticmethod
    def motion(actor, event, self):
        if self.pressed:
            x = self.x
            y = self.y
            if self.width:
                x = self.x + event.x - self._x
            if self.height:
                y = self.y + event.y - self._y
            self.container.set_position(x, y)


def main(argv):
    clutter.init()

    width, height = 800, 600

    stage = clutter.stage_get_default()
    stage.set_size(width, height)
    stage.set_color(clutter.color_parse("#000"))

    mask = clutter.Group()
    mask.set_clip(0, 0, width, height)
    mask.show()

    container = clutter.Group()

    label = clutter.Label()
    label.set_text(" “The quick brown fox jumps over the lazy dog” ")
    label.set_position(0, 200)
    label.set_font_name("Droid Serif 100")
    label.set_color(clutter.color_parse("#ddd"))
    label.show()

    label2 = clutter.Label()
    label2.set_text(" “The quick brown fox jumps over the lazy dog” ")
    label2.set_position(0, height + 200)
    label2.set_font_name("Droid Sans 100")
    label2.set_color(clutter.color_parse("#ddd"))
    label2.show()

    label3 = clutter.Label()
    label3.set_text(" “The quick brown fox jumps over the lazy dog” ")
    label3.set_position(0, 2*height + 200)
    label3.set_font_name("Arial Narrow 100")
    label3.set_color(clutter.color_parse("#ddd"))
    label3.show()


    color = clutter.color_parse("#fff")
    for j in xrange(6):
        for i in xrange(label.get_size()[0] / (width/2) + 1):
            r = clutter.Rectangle()
            r.set_size(width/2, height/2)
            r.set_position(i * (width/2), j * (height / 2))
            c = color.from_hls(i * 20, (j+1)*32, 255)
            c.alpha = 255
            r.set_color(c)
            container.add(r)

    container.add(label)
    container.add(label2)
    container.add(label3)

    bg = clutter.Rectangle()
    bg.set_size(width, height)
    bg.set_color(clutter.color_parse("#00000000"))
    bg.set_reactive(True)

    mask.add(bg)
    mask.add(container)

    stage.add(mask)
    stage.show_all()

    slide = Slider(bg, container,
                   width=label.get_size()[0],
                   height=3*height,
                   stepx=width/2,
                   stepy=height/2)

    stage.connect("key-press-event", clutter.main_quit)

    clutter.main()
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))