# Step 1 - importing the necessary libraries

import pygame, os
import random
from pygame.locals import *


# Step 2 - Define any necessary functions

# First use the load_image function we created earlier
def load_image(name):
    fullname = os.path.join('data', name)
    try:
        image = pygame.image.load(fullname)
	# Here insead of colorkey code we check for alpha values
	if image.get_alpha is None:
		image = image.convert()
	else:
		image = image.convert_alpha()
    except pygame.error, message:
        print 'Cannot load image:', fullname
        raise SystemExit, message
    return image, image.get_rect()

# And define AllKeysUp 

def AllKeysUp(key): return key.type == KEYUP

# Step 3 - Define the Classes

class SimpleSprite(pygame.sprite.Sprite):
	def __init__(self, name=None):
		pygame.sprite.Sprite.__init__(self)
 		if name:
			self.image, self.rect = load_image(name)
		else:
			pass
	
	def set_image(self, newSurface, newRect=None):
		self.image = newSurface
		if newRect:
			self.rect  = newRect
		else:
			pass


class Monkey_Sprite(pygame.sprite.Sprite):
    def __init__(self, game):
        pygame.sprite.Sprite.__init__(self)
        self.image, self.rect = load_image('monkey.png')
	self.rightFacingImg = self.image
	self.leftFacingImg = pygame.transform.flip( self.image, 1, 0)

        self.direction = 0   
        self.increment = 25
        self.oldPos = self.rect
        self.game = game
        self.listenKeys = {}

    def update(self):
        self.check_land()
        self.move()
        if self.direction == 0:
            self.image = self.rightFacingImg
        else:
            self.image = self.leftFacingImg
        self.check_crash()
        

    def check_crash(self):
        global snakesprites
        crash_list = pygame.sprite.spritecollide(self, snakesprites, 0)
        if len(crash_list) is not 0:
            self.game.crash(self)

    def move(self):
        self.oldPos = self.rect
        self.rect = self.rect.move(self.increment, 0)
        if self.rect.right > 640:
            self.rect.top += 40
            self.increment = -25
            self.direction = 1
        if self.rect.left < 0:
            self.rect.top += 40
            self.increment = 25
            self.direction = 0

    def signal_key( self, event, remainingEvents ):
		if self.listenKeys.has_key( event.key ) \
		  and event.type is KEYDOWN:
			self.listenKeys[event.key]( remainingEvents )

    def check_land(self):
        if (self.rect.top == 640) and (self.rect.left == 1):
            self.game.land()


class Banana(pygame.sprite.Sprite):
    def __init__(self, rect, game):
        pygame.sprite.Sprite.__init__(self) 
        self.increment =16
        self.image, self.rect = load_image("fruit.png")
        if rect is not None:
            self.rect = rect
        self.game = game

    def update(self):
        self.move()

    def move(self):
        self.rect = self.rect.move(0, self.increment)
        if self.rect.top==480:
            self.game.miss()
        else:
            self.check_hit()

    def check_hit(self):
        global snakesprites
        collide_list = pygame.sprite.spritecollide(self, snakesprites,0)
        if len(collide_list) is not 0:
            self.game.hit()
        
class Snake_Grass:
    def __init__(self, difficulty):
        global snakesprites
        global block
        for i in range(10):
            for j in range(random.randrange(0,difficulty*5)):
                block = SimpleSprite("snake.png")
                block.rect.move_ip(((i+1)*40),480-(j*40))
                snakesprites.add(block)

    def clear(self):
        global snakesprites
        snakesprites.empty()

class MonkeyToss:
    def __init__(self, charGroup):
        self.charGroup = charGroup

        self.difficulty = 2
        self.listenKeys = {K_SPACE: self.drop_fruit}
        self.snake = Snake_Grass(self.difficulty)

        self.monkey = Monkey_Sprite(self)
        self.charGroup.add( [self.monkey] )
        self.fruit = None
        

    def crash(self, oldMonkey):
        self.monkey.kill()
        self.monkey = Monkey_Sprite(self)
        self.charGroup.add ([self.monkey])
        
    def land(self):
        self.monkey.kill()
        self.monkey = Monkey_Sprite(self)
        self.charGroup.add([self.monkey])

    def drop_fruit(self):
        if self.fruit is None:
            self.fruit = Banana(self.monkey.rect, self)
            self.charGroup.add([self.fruit])

    def miss(self):
        self.fruit.kill()
        self.fruit = None

    def hit(self):
        global snakesprites
        My_Group = pygame.sprite.Group()
        colliderects = []
        for i in range(3):
            for j in range((self.fruit.rect.bottom+16-self.monkey.rect.top)/16):
                rect = Rect((self.fruit.rect.left-32+i*32,self.fruit.rect.bottom-j*16),(25,16))
                colliderects.append(rect)

        for rect in colliderects:
            sprite = SimpleSprite()
            sprite.rect = rect
            My_Group.add(sprite)

        list = pygame.sprite.groupcollide(My_Group, snakesprites, 1,1)
        
        self.fruit.kill()
        self.fruit = None
        
	
    def signal_key( self, event, remainingEvents ):
        if self.listenKeys.has_key( event.key ):
            self.listenKeys[event.key]()
        else:
            self.monkey.signal_key( event, remainingEvents )
		


def main():
    global screen
    global background
    global snakesprites
    global block
    pygame.init()
    screen = pygame.display.set_mode((640, 480))
    pygame.display.set_caption('Monkey Toss')

    
    background, tmp_rect = load_image('background.png')
    
    screen.blit(background, (0, 0))
    pygame.display.flip()

    allsprites = pygame.sprite.RenderUpdates()
    
    snakesprites= pygame.sprite.RenderUpdates()


    block = None
    
    game = MonkeyToss(allsprites)
    
    clock = pygame.time.Clock()
    random.seed(111111)

    oldfps = 0
    while 1:
        clock.tick(10)
        newfps = int(clock.get_fps())
        if newfps is not oldfps:
            oldfps = newfps

        oldEvents = []
        remainingEvents = pygame.event.get()
        for event in remainingEvents:
            oldEvents.append( remainingEvents.pop(0) )
            upKeys = filter( AllKeysUp, remainingEvents )

            if event.type == QUIT:
                return
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                return
            elif event.type == KEYDOWN or event.type == KEYUP:
                game.signal_key( event, upKeys )

	#Draw Everything
        allsprites.clear( screen, background)
        snakesprites.clear(screen, background)

        allsprites.update()

        changedRects2 = allsprites.draw(screen)
        changedRects3 = snakesprites.draw(screen)
        pygame.display.update(changedRects2+changedRects3)



if __name__ == "__main__":
    main()