import direct.directbase.DirectStart
from direct.actor.Actor import Actor
from direct.fsm.FSM import FSM
from panda3d.core import *
from direct.gui.OnscreenText import OnscreenText
from direct.task.Task import Task
from direct.interval.IntervalGlobal import Sequence
import sys

class Game(object):
    """
        This is a very simple FPS like -
         a building block of any game i guess
    """
    def __init__(self):

        props = WindowProperties()
        props.setCursorHidden(True)
        base.win.requestProperties(props)
        """ create a FPS type game """
        self.initCollision()
        self.loadLevel()
        self.initPlayer()
        base.accept( "escape" , sys.exit)
        base.disableMouse()


    def initCollision(self):
        """ create the collision system """
        base.cTrav = CollisionTraverser()
        base.pusher = CollisionHandlerPusher()

    def loadLevel(self):
        """ load the self.level
            must have
            <Group> *something* {
              <Collide> { Polyset keep descend }
            in the egg file
        """
        self.level = loader.loadModel('level2.egg')
        self.level.setPos(0,0,0)
        self.level.reparentTo(render)
        self.level.setTwoSided(True)

        self.door = loader.loadModel('door.egg')
        self.door.setPos(0, 0, 0)
        self.door.reparentTo(render)
        self.door.setTwoSided(True)



    def initPlayer(self):
        """ loads the player and creates all the controls for him"""
        self.player = Player(self)

        #base.pusher.addCollider(self.door, self.node)


class Player(object):
    """
        Player is the main actor in the fps game
    """
    speed = 50
    FORWARD = Vec3(0,2,0)
    BACK = Vec3(0,-1,0)
    LEFT = Vec3(-1,0,0)
    RIGHT = Vec3(1,0,0)
    STOP = Vec3(0)
    walk = STOP
    strafe = STOP
    readyToJump = False
    jump = 0

    def __init__(self, game):
        self.game = game
        """ inits the player """
        self.loadModel()
        self.setUpCamera()
        self.createCollisions()
        self.attachControls()
        # init mouse update task
        taskMgr.add(self.mouseUpdate, 'mouse-task')
        taskMgr.add(self.moveUpdate, 'move-task')
        taskMgr.add(self.jumpUpdate, 'jump-task')

        self.pickerHandler = CollisionHandlerQueue()  # Make a handler
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
         # Register the ray as something that can cause collisions
        base.cTrav.addCollider(self.pickerNP, self.pickerHandler)

    def loadModel(self):
        """ make the nodepath for player """
        self.node = NodePath('player')
        self.node.reparentTo(render)
        self.node.setPos(0,0,20)
        self.node.setScale(.1)
        self.gun = Actor('GunTest.egg', {
            'fire1': 'GunTest-fire1.egg',
            })
        self.gun.setPos(3, 5, -1.5)
        self.gun.setH(-80)
        self.gun.reparentTo(base.camera)

    def setUpCamera(self):
        """ puts camera at the players node """
        pl =  base.cam.node().getLens()
        pl.setFov(90)
        base.cam.node().setLens(pl)
        base.camera.reparentTo(self.node)

    def createCollisions(self):
        """ create a collision solid and ray for the pllayer """
        cn = CollisionNode('player')
        cn.addSolid(CollisionTube(0,0,0,0,.1,0,.1))
        solid = self.node.attachNewNode(cn)
        base.cTrav.addCollider(solid, base.pusher)
        base.pusher.addCollider(solid, self.node, base.drive.node())

        # init players floor collisions
        ray = CollisionRay()
        ray.setOrigin(0,0,20)
        ray.setDirection(0,0,-1)
        cn = CollisionNode('playerRay')
        cn.addSolid(ray)
        solid = self.node.attachNewNode(cn)
        self.nodeGroundHandler = CollisionHandlerQueue()
        base.cTrav.addCollider(solid, self.nodeGroundHandler)
        base.cTrav.showCollisions(render)

    def attachControls(self):
        """ attach key events """
        base.accept( "space" , self.__setattr__,["readyToJump",True])
        base.accept( "space-up" , self.__setattr__,["readyToJump",False])
        base.accept( "s" , self.__setattr__,["walk",self.STOP] )
        base.accept( "w" , self.__setattr__,["walk",self.FORWARD])
        base.accept( "s" , self.__setattr__,["walk",self.BACK] )
        base.accept( "s-up" , self.__setattr__,["walk",self.STOP] )
        base.accept( "w-up" , self.__setattr__,["walk",self.STOP] )
        base.accept( "a" , self.__setattr__,["strafe",self.LEFT])
        base.accept( "d" , self.__setattr__,["strafe",self.RIGHT] )
        base.accept( "a-up" , self.__setattr__,["strafe",self.STOP] )
        base.accept( "d-up" , self.__setattr__,["strafe",self.STOP] )
        base.accept("mouse1", self.mouseHandler)
        base.accept( "e" , self.doorHandler)
        base.accept( "f", self.jerkCamera)

    def jerkCamera(self):
        if base.camera.getP() < 80:
            base.camera.setP(base.camera.getP()+10)

    def doorHandler(self):
        mpos = base.mouseWatcherNode.getMouse()
        self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())

        base.cTrav.traverse(render)

        if self.pickerHandler.getNumEntries() > 0:
            # This is so we get the closest object
            self.pickerHandler.sortEntries()
            pickedObj = self.pickerHandler.getEntry(0).getIntoNodePath()
        render.ls()
        print (pickedObj.getH())
        print (pickedObj.getName())
        if pickedObj.getParent().getH() >= 90:
            doorHprInterval2 = pickedObj.getParent().hprInterval(1, Point3(0, 0, 0), startHpr=Point3(90,0,0))
            doorHprInterval2.start()
            print ("Used interval 1")
        else:
            doorHprInterval1 = pickedObj.getParent().hprInterval(1,
                                                        Point3(90, 0, 0),
                                                        startHpr=Point3(0, 0, 0))
            doorHprInterval1.start()
        print ("Used Interval 2")



    def mouseHandler(self):
        print ("Mouse handler")
        self.gun.play('fire1')
        mpos = base.mouseWatcherNode.getMouse()
        self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
        base.cTrav.traverse(render)
        if self.pickerHandler.getNumEntries() > 0:
            # This is so we get the closest object
            self.pickerHandler.sortEntries()
            pickedObj = self.pickerHandler.getEntry(0).getIntoNodePath()
            pickedObj.ls()

    def mouseUpdate(self,task):
        """ this task updates the mouse """
        md = base.win.getPointer(0)
        x = md.getX()
        y = md.getY()
        if base.win.movePointer(0, int(base.win.getXSize()/2), int(base.win.getYSize()/2)):
            self.node.setH(self.node.getH() -  (x - base.win.getXSize()/2)*0.1)
            base.camera.setP(base.camera.getP() - (y - base.win.getYSize()/2)*0.1)
        return task.cont

    def moveUpdate(self,task):
        """ this task makes the player move """
        # move where the keys set it
        self.node.setPos(self.node,self.walk*globalClock.getDt()*self.speed)
        self.node.setPos(self.node,self.strafe*globalClock.getDt()*self.speed)
        return task.cont

    def jumpUpdate(self,task):
        """ this task simulates gravity and makes the player jump """
        # get the highest Z from the down casting ray
        highestZ = -900
        for i in range(self.nodeGroundHandler.getNumEntries()):
            entry = self.nodeGroundHandler.getEntry(i)
            z = entry.getSurfacePoint(render).getZ()
            if z > highestZ and entry.getIntoNode().getName() == "Cube":
                highestZ = z
        # gravity effects and jumps
        self.node.setZ(self.node.getZ()+self.jump*globalClock.getDt())
        self.jump -= 20*globalClock.getDt()
        if highestZ > self.node.getZ()-1:
            self.jump = 0
            self.node.setZ(highestZ+1)
            if self.readyToJump:
                self.jump = 7
        return task.cont

Game()
base.run()