import pygame, data
from pygame.locals import *

import level
import robot
import enemy
import camera
import gui
import fx

class Play:
    def __init__(self, screen, clock, levelName, gemData):
        self.screen = screen
        self.gemData = gemData
        self.clock = clock
        self.startSound = data.load_sound("gravityReverse.wav")
        self.dieSound = data.load_sound("select.wav")
        self.background = pygame.Surface(self.screen.get_size())
        self.background = self.background.convert()
        self.background.fill((0,0,0))
        self.fname = ""
        if levelName == "Jungle":
            self.fname = "level1.txt"
            self.introBanner,null = data.load_image("jungleIntro.png",(0,255,0))
            self.robot = robot.Robot("Climb")
        elif levelName == "Space":
            self.fname = "level2.txt"
            self.introBanner,null = data.load_image("spaceIntro.png",(0,255,0))
            self.robot = robot.Robot("Gravity")
        elif levelName == "Lava":
            self.fname = "level3.txt"
            self.introBanner,null = data.load_image("lavaIntro.png",(0,255,0))
            self.robot = robot.Robot("Runner")
        elif levelName == "War":
            self.fname = "level4.txt"
            self.introBanner,null = data.load_image("warIntro.png",(0,255,0))
            self.robot = robot.Robot("Firepower")
        elif levelName == "Final":
            self.fname = "level5.txt"
            self.introBanner,null = data.load_image("finalIntro.png",(0,255,0))
        self.enemyL = []
        self.eventL = {}
        self.roboProjectiles = []
        self.enemyProjectiles = []
        self.fxArray = []
        self.level = level.Level(self.fname,self.enemyL,self.eventL)
        self.gui = gui.Gui(self.robot.roboType, gemData)
        self.robot.setStart(self.eventL["start"][0],self.eventL["start"][1])
        self.camera = camera.Camera()
        self.camera.setTarget(self.robot.actor)
        self.camera.setMaxCamera((self.level.width*32)-640,(self.level.height*32)-480)
        self.lives = 3 # each time you start the level, you get 3 lives
        self.state = "Intro"
        self.cutSceneCnt = 0 
        self.introTime = 90 # 90 = 1.5 second
        self.finishTime = 120 # 120 = 2 seconds
        self.deathTime = 60 # 60 = 1 second
        self.finishedTime = 240 # 240 = 4 seconds
        #hack this in!
        self.dieSound.play()
    
    def update(self):
        rvalue = self.logic()
        self.render()
        self.clock.tick(60)
        return rvalue

    def logic(self):
        for event in pygame.event.get():
            if event.type == QUIT:
                return "Quit"
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    return "Quit"
                elif event.key == K_LEFT:
                    self.robot.moveLeft(True)
                elif event.key == K_RIGHT:
                    self.robot.moveRight(True)
                elif event.key == K_UP:
                    self.robot.moveUp(True)
                elif event.key == K_DOWN:
                    self.robot.moveDown(True)
                elif event.key == 120:
                    self.robot.jump(True)
                elif event.key == 122:
                    self.robot.fire(True)
                elif event.key == K_RETURN:
                    pass
            elif event.type == KEYUP:
                if event.key == K_LEFT:
                    self.robot.moveLeft(False)
                elif event.key == K_RIGHT:
                    self.robot.moveRight(False)
                elif event.key == K_UP:
                    self.robot.moveUp(False)
                elif event.key == K_DOWN:
                    self.robot.moveDown(False)
                elif event.key == 122:
                    self.robot.fire(False)
                elif event.key == 120:
                    self.robot.jump(False)
        if self.state == "Intro":
            if self.cutSceneCnt > self.introTime:
                self.state = "Playing"
                self.cutSceneCnt = 0
            else:
                self.cutSceneCnt+=1
            self.camera.update()
        elif self.state == "Dead":
            rx,ry = self.robot.actor.getPos()
            for p in self.roboProjectiles:
                p.update(self.level, rx, ry, self.roboProjectiles, self.fxArray)
            for p in self.enemyProjectiles:
                p.update(self.level, rx, ry, self.enemyProjectiles)
            for e in self.enemyL:
                e.update(self.level,rx,ry,self.enemyProjectiles)
            for x in self.fxArray:
                x.update(self.fxArray)
            if self.cutSceneCnt > self.deathTime:
                if self.lives <= 0:
                    return "LevelSelect"
                else:
                    self.state = "Intro"
                    self.dieSound.play()
                    self.enemyL = [] # clear enemy list
                    self.eventL = {} # clear event list
                    self.roboProjectiles = []
                    self.enemyProjectiles = []
                    self.fxArray = []
                    self.level = level.Level(self.fname,self.enemyL,self.eventL)
                    self.robot.reset()
                    self.robot.setStart(self.eventL["start"][0],self.eventL["start"][1])
                    self.lives -= 1 # REDUCE LIVES HERE.. kinda hacky
            else:
                self.cutSceneCnt += 1
        elif self.state == "Finished":
            if self.cutSceneCnt > self.finishedTime:
                return "LevelSelect"
            else:
                self.cutSceneCnt+=1
        elif self.state == "Playing":
            self.robot.update(self.level, self.enemyL, self.roboProjectiles)
            rx,ry = self.robot.actor.getPos()
            if self.robot.hitSpike == True:
                self.robot.damage()
                self.fxArray.append(fx.FX('Explosion1',rx,ry))
                self.state = "Dead"
                self.startSound.play()
                return "Idle" # cut it short!
            rw = self.robot.actor.rect.width
            rh = self.robot.actor.rect.height
            # Enemies vs. Robot Projectiles
            for p in self.roboProjectiles:
                px,py = p.actor.getPos()
                pw = p.actor.rect.width
                ph = p.actor.rect.height
                # check to see if we collided with player (boomerang)
                if self.rectCollide(rx+5,ry+5,rw-10,rh-10,px+5,py+5,pw-10,ph-10):
                    p.explode(self.roboProjectiles)
                    break
                for e in self.enemyL:
                    ex,ey = e.actor.getPos()
                    ew = e.actor.rect.width
                    eh = e.actor.rect.height
                    if self.rectCollide(px,py,pw,ph,ex,ey,ew,eh):
                        e.takeDamage(p.getDamage(),self.enemyL)
                        self.fxArray.append(fx.FX('Explosion1',ex,ey))
                        p.explode(self.roboProjectiles)
                        p = None
                        break
                # p can remove itself if it needs to, so update after we check
                # for collisions!
                if p != None:
                    p.update(self.level, rx, ry, self.roboProjectiles, self.fxArray)
            # Robot vs. Enemies
            for e in self.enemyL:
                e.update(self.level,rx,ry,self.enemyProjectiles)
                ex,ey = e.actor.getPos()
                ew = e.actor.rect.width
                eh = e.actor.rect.height
                # tweak our values a tiny bit to make it easier
                if self.rectCollide(rx+2,ry+2,rw-4,rh-4,ex+2,ey+2,ew-4,eh-4):
                    self.robot.damage()
                    self.fxArray.append(fx.FX('Explosion1',rx,ry))
                    self.state = "Dead"
                    self.startSound.play()
            # Enemy Projectiles vs. Robot
            for p in self.enemyProjectiles:
                p.update(self.level, rx, ry, self.enemyProjectiles)
                px,py = p.actor.getPos()
                pw = p.actor.rect.width
                ph = p.actor.rect.height
                if self.rectCollide(px,py,pw,ph,rx,ry,rw,rh):
                    self.robot.damage()
                    self.fxArray.append(fx.FX('Explosion1',rx,ry))
                    p.explode(self.enemyProjectiles)
                    self.state = "Dead"
                    self.startSound.play()
            for x in self.fxArray:
                x.update(self.fxArray)
            gx,gy = self.eventL["gem"].actor.getPos()
            gw = self.eventL["gem"].actor.rect.width
            gh = self.eventL["gem"].actor.rect.height
            if self.rectCollide(rx,ry,rw,rh,gx,gy,gw,gh):
                self.state = "Finished"
                hasGem = False
                for gem in self.gemData:
                    if self.eventL["gem"].getColor() == gem.getColor():
                        hasGem = True
                        break
                if hasGem == False:
                    self.gemData.append(self.eventL["gem"])
            self.camera.update()
        return "Idle"

    def render(self):
        self.screen.blit(self.background, (0,0))
        camX,camY = self.camera.pos()
        self.level.draw(self.screen,camX,camY)
        for e in self.enemyL:
            e.draw(self.screen,camX,camY)
        for x in self.fxArray:
            x.draw(self.screen,camX,camY)
        for p in self.roboProjectiles:
            p.draw(self.screen,camX,camY)
        for p in self.enemyProjectiles:
            p.draw(self.screen,camX,camY)
        if self.state != "Dead":
            self.robot.draw(self.screen,camX,camY)
        if self.state != "Finished": # we completed, so don't show the gem HACK
            self.eventL["gem"].draw(self.screen,camX,camY)
        if self.state == "Intro":
            self.screen.blit(self.introBanner, (120, 100))
        self.gui.draw(self.screen,self.lives)
        pygame.display.flip()

    def rectCollide(self, r1x, r1y, r1w, r1h, r2x, r2y, r2w, r2h):
        if ( (r1y + r1h) < (r2y) ):
            return False
        if ( (r1y) > (r2y+r2h) ):
            return False
        if ( (r1x+r1w) < (r2x) ):
            return False
        if ( (r1x) > (r2x+r2w) ):
            return False
        return True