from machine import Pin
import time
import uasyncio as asyncio

stepping = [[1,0,1,0],[1,0,0,0],[1,0,0,1],[0,0,0,1],[0,1,0,1],[0,1,0,0],[0,1,1,0],[0,0,1,0]]

class Stepper:
    def __init__(self,pins,stepsPerRev=400,stepDurationMs=50,inverted=False):
        self._pins = [Pin(p, Pin.OUT) for p in  pins]
        self.stepnum = 0
        self.rotDirection = 1
        self._rotTarget = 0
        self.stepDurationMs = stepDurationMs
        self._speedMs = 0
        self._lastStepTime = time.time()
        self.stepsPerRev=stepsPerRev
        self.started_async = False
        self.inverted = inverted

    def start(self):
        if not self.started_async:
            self.started_async = True
            loop = asyncio.get_event_loop()
            loop.create_task(self._update_async())

    def _setPins(self,level):
        self._pins[0].value(level[0])
        self._pins[1].value(level[1])
        self._pins[2].value(level[2])
        self._pins[3].value(level[3])

    def getStepsToTarget(self):
        return ((self._rotTarget - self.stepnum)*self.rotDirection)%self.stepsPerRev

    def rotateTo(self, target,duration=0,direction=0):
        """sets the rotation target and (if direction == 0) calculates if
        it should rotate left or right"""
        self._rotTarget = int(target*self.stepsPerRev) % self.stepsPerRev
        if not self.isAtTarget():
            if (direction == 0):
                self.rotDirection = 1 if (self._rotTarget - self.stepnum)%self.stepsPerRev \
                    < self.stepsPerRev/2 else -1
            else:
                self.rotDirection = direction
            self._speedMs = max(int(self.stepDurationMs),duration*1000/self.getStepsToTarget())

    async def _update_async(self):
        while(True):
            await asyncio.sleep_ms(self.stepDurationMs)
            if not self.isAtTarget():
                self._update()
            else:
                self.disablePower()

    def _update(self):
        self.stepnum = (self.stepnum + self.rotDirection) % self.stepsPerRev
        self._setPins(stepping[(self.stepnum%8) if not self.inverted else ((8-self.stepnum)%8)])

    def disablePower(self):
        self._setPins([0,0,0,0])

    def getOrientation(self):
        return self.stepnum / self.stepsPerRev

    def getTarget(self):
        return (self._rotTarget / self.stepsPerRev)

    def isAtTarget(self):
        return (self._rotTarget%self.stepsPerRev == self.stepnum%self.stepsPerRev)