import time
import threading
import DobotDllType as dType



"""
Six actuators:
    linear rail
    base rotation 
    rear arm
    forarm
    gripperrotation
    gripper

First five takes argument 1 or -1 (direction)
Example:
#initialisation 
c = Candybot()
c.linear(1) # move linear in positive direction
c.gripp() # gripp candy
c.letgo() # let go of candy
c.stopcmp() # stoop compressor

c.panic() # stops everything
"""

class Candybot:
    def __init__(self):
        self.jointspeed = 100
        self.lastjointspeed = 100

        self.linearspeed = 100
        self.lastleinearspeed = 100
        
        CON_STR = {
            dType.DobotConnect.DobotConnect_NoError:  "DobotConnect_NoError",
            dType.DobotConnect.DobotConnect_NotFound: "DobotConnect_NotFound",
            dType.DobotConnect.DobotConnect_Occupied: "DobotConnect_Occupied"}

        #Load Dll
        self.api = dType.load()

        #Connect Dobot
        state = dType.ConnectDobot(self.api, "", 115200)[0]
        print("Connect status:",CON_STR[state])

        if (state == dType.DobotConnect.DobotConnect_NoError):

            #Clean Command Queued
            dType.SetQueuedCmdClear(self.api)

            #Async Motion Params Setting
            dType.SetHOMEParams(self.api, 250, 0, 50, 0, isQueued = 1)
            dType.SetJOGJointParams(self.api, 2, 200, 2, 200, 2, 200, 2, 200, isQueued = 1)
            dType.SetJOGCommonParams(self.api, 100, 100, isQueued = 1)

            #linear rail
            dType.SetDeviceWithL(self.api, 1)
            dType.SetJOGLParams(self.api,  200, 200, isQueued=0)

            #Async Home
            dType.SetHOMECmd(self.api, temp = 0, isQueued = 1)

    def disconnect(self):
        #Disconnect Dobot
        dType.DisconnectDobot(self.api)

    def base(self, direction):
        if direction == 1:
            dType.SetJOGCmd(self.api,1,1)
    
        elif direction == -1:
            dType.SetJOGCmd(self.api,1,2)

        else :
            return
        threading.Timer(0.1,self.stop).start()
        #dType.SetWAITCmd(self.api, 1, isQueued=0)
        #dType.SetJOGCmd(self.api, 1, 0)

    def rearArm(self, direction):
        if direction == 1:
            dType.SetJOGCmd(self.api,1,3)
    
        elif direction == -1:
            dType.SetJOGCmd(self.api,1,4)

        else :
            return
        #dType.SetWAITCmd(self.api, 1, isQueued=0)
        #dType.SetJOGCmd(self.api, 1, 0)
        threading.Timer(0.1,self.stop).start()

    def forearm(self, direction):
        if direction == 1:
            dType.SetJOGCmd(self.api,1,5)
    
        elif direction == -1:
            dType.SetJOGCmd(self.api,1,6)

        else :
            return
        #dType.SetWAITCmd(self.api, 1, isQueued=0)
        #dType.SetJOGCmd(self.api, 1, 0)
        threading.Timer(0.1,self.stop).start()

    def gripperRotation(self, direction):
        if direction == 1:
            dType.SetJOGCmd(self.api,1,7)
    
        elif direction == -1:
            dType.SetJOGCmd(self.api,1,8)

        else :
            return
        #dType.SetWAITCmd(self.api, 1, isQueued=0)
        #dType.SetJOGCmd(self.api, 1, 0)
        threading.Timer(0.1,self.stop).start()

    def linear(self, direction):
        if direction == 1:
            dType.SetJOGCmd(self.api,1,9)
    
        elif direction == -1:
            dType.SetJOGCmd(self.api,1,10)

        else :
            return
        #dType.SetWAITCmd(self.api, 1, isQueued=0)
        #dType.SetJOGCmd(self.api, 1, 0)
        self.lint = threading.Timer(0.2,self.stop)
        self.lint.start()

    def gripp(self):
        dType.SetEndEffectorGripper(self.api, 1,  1, isQueued=0)
    
    def letgo(self):
        dType.SetEndEffectorGripper(self.api, 1,  0, isQueued=0)

    def stop(self):
        dType.SetJOGCmd(self.api, 1, 0)

    def stopcmp(self):
        dType.SetEndEffectorGripper(self.api, 0,  0, isQueued=0)

    def panic(self):
        dType.SetQueuedCmdForceStopExec(self.api)

    def getCurrentCmd(self):
        return dType.GetQueuedCmdCurrentIndex(self.api)
    
    def JOGtest(self):
        dType.SetJOGCmd(self.api,1,1)
        dType.SetJOGCmd(self.api,1,9)
    
    def JOGtest2(self):
        dType.SetJOGLParams(self.api,  100, 200, isQueued=0)
        dType.SetJOGCmd(self.api,1,9)
        time.sleep(1)
        for speed in range(100,10,-10):
            time.sleep(0.3)
            dType.SetJOGLParams(self.api,  speed, 200, isQueued=0)
         

    def setparams(self, name, speed):
        lookup = {'base' : 0, 'reararm' : 1, 'forearm' : 2, 'gripperroation' :3}
        if name == 'rail':
            dType.SetJOGLParams(self.api,  speed, 200, isQueued=0)
    
        else:
            speeds = [0,0,0,0]
            speeds[lookup[name]] = speed
            dType.SetJOGJointParams(self.api, speeds[0], 200, speeds[1], 200, speeds[2], 200, speeds[3], 200, isQueued = 1)




c = Candybot()


def slide_left():
    c.linear(-1)

def slide_right():
    c.linear(1)
    
def rotate_left():
    c.base(-1)

def rotate_right():
    c.base(1)

def forward():
    c.forearm(1)

def back():
    c.forearm(-1)

def up():
    c.rearArm(1)

def down():
    c.rearArm(-1)

def grab():
    c.gripp()
    c.stopcmp()

def drop():
    c.letgo()
    c.stopcmp()

def stop():
    c.panic()

def getCurrentCmd():
    return c.getCurrentCmd()

def updateLinearSpeed():    
    pass



    
        
