# Copyright (c) 2015-2018 Volodymyr Shymanskyy. See the file LICENSE for copying permission.

_VERSION = "0.2.0"

import struct
import time

try:
    import machine
    gettime = lambda: time.ticks_ms()
except ImportError:
    const = lambda x: x
    gettime = lambda: int(time.time() * 1000)

def dummy(*args):
    pass 

MSG_RSP = const(0)
MSG_LOGIN = const(2)
MSG_PING  = const(6)

MSG_TWEET = const(12)
MSG_EMAIL = const(13)
MSG_NOTIFY = const(14)
MSG_BRIDGE = const(15)
MSG_HW_SYNC = const(16)
MSG_INTERNAL = const(17)
MSG_PROPERTY = const(19)
MSG_HW = const(20)
MSG_EVENT_LOG = const(64)

MSG_REDIRECT  = const(41)  # TODO: not implemented
MSG_DBG_PRINT  = const(55) # TODO: not implemented

STA_SUCCESS = const(200)
STA_INVALID_TOKEN = const(9)

DISCONNECTED = const(0)
CONNECTING = const(1)
CONNECTED = const(2)

print("""
    ___  __          __
   / _ )/ /_ _____  / /__
  / _  / / // / _ \\/  '_/
 /____/_/\\_, /_//_/_/\\_\\
        /___/ for Python v""" + _VERSION + "\n")

class BlynkProtocol:
    def __init__(self, auth, heartbeat=10, buffin=1024, log=None):
        self.callbacks = {}
        self.heartbeat = heartbeat*1000
        self.buffin = buffin
        self.log = log or dummy
        self.auth = auth
        self.state = DISCONNECTED
        self.connect()

    def on(self, evt, func):
        self.callbacks[evt] = func
        
    def ON(blynk, evt):
        class Decorator:
            def __init__(self, func):
                self.func = func
                blynk.callbacks[evt] = func
            def __call__(self):
                return self.func()
        return Decorator

    def emit(self, evt, *a, **kv):
        self.log("Event:", evt, "->", *a)
        if evt in self.callbacks:
            self.callbacks[evt](*a, **kv)

    def virtual_write(self, pin, *val):
        self.sendMsg(MSG_HW, 'vw', pin, *val)

    def set_property(self, pin, prop, *val):
        self.sendMsg(MSG_PROPERTY, pin, prop, *val)

    def sync_virtual(self, *pins):
        self.sendMsg(MSG_HW_SYNC, 'vr', *pins)

    def notify(self, msg):
        self.sendMsg(MSG_NOTIFY, msg)

    def log_event(self, event, descr=None):
        if descr==None:
            self.sendMsg(MSG_EVENT_LOG, event)
        else:
            self.sendMsg(MSG_EVENT_LOG, event, descr)

    def sendMsg(self, cmd, *args, **kwargs):
        if "id" in kwargs:
            id = kwargs.id
        else:
            id = self.msg_id
            self.msg_id += 1
            if self.msg_id > 0xFFFF:
                self.msg_id = 1
                
        if cmd == MSG_RSP:
            data = b''
            dlen = args[0]
        else:
            data = ('\0'.join(map(str, args))).encode('ascii')
            dlen = len(data)
        
        self.log('<', cmd, id, '|', *args)
        msg = struct.pack("!BHH", cmd, id, dlen) + data
        self.lastSend = gettime()
        self._send(msg)

    def connect(self):
        if self.state != DISCONNECTED: return
        self.msg_id = 1
        (self.lastRecv, self.lastSend, self.lastPing) = (gettime(), 0, 0)
        self.bin = b""
        self.state = CONNECTING
        self.sendMsg(MSG_LOGIN, self.auth)

    def disconnect(self):
        if self.state == DISCONNECTED: return
        self.state = DISCONNECTED
        self.emit('disconnected')

    def process(self, data=b''):
        if not (self.state == CONNECTING or self.state == CONNECTED): return
        now = gettime()
        if now - self.lastRecv > self.heartbeat+(self.heartbeat/2):
            return self.disconnect()
        if (now - self.lastPing > self.heartbeat/10 and
            (now - self.lastSend > self.heartbeat or
             now - self.lastRecv > self.heartbeat)):
            self.sendMsg(MSG_PING)
            self.lastPing = now
        
        if data != None and len(data):
            self.bin += data

        while True:
            if len(self.bin) < 5: return
            
            cmd, i, dlen = struct.unpack("!BHH", self.bin[:5])
            if i == 0: return self.disconnect()
                      
            self.lastRecv = now
            if cmd == MSG_RSP:
                self.bin = self.bin[5:]

                self.log('>', cmd, i, '|', dlen)
                if self.state == CONNECTING and i == 1:
                    if dlen == STA_SUCCESS:
                        self.state = CONNECTED
                        dt = now - self.lastSend
                        self.sendMsg(MSG_INTERNAL, 'ver', _VERSION, 'h-beat', self.heartbeat//1000, 'buff-in', self.buffin, 'dev', 'python')
                        self.emit('connected', ping=dt)
                    else:
                        if dlen == STA_INVALID_TOKEN:
                            print("Invalid auth token")
                        return self.disconnect()
            else:
                if dlen >= self.buffin:
                    print("Cmd too big: ", dlen)
                    return self.disconnect()
            
                if len(self.bin) < 5+dlen: return
                
                data = self.bin[5:5+dlen]
                self.bin = self.bin[5+dlen:]

                args = list(map(lambda x: x.decode('ascii'), data.split(b'\0')))

                self.log('>', cmd, i, '|', ','.join(args))
                if cmd == MSG_PING:
                    self.sendMsg(MSG_RSP, STA_SUCCESS, id=i)
                elif cmd == MSG_HW or cmd == MSG_BRIDGE:
                    if args[0] == 'vw':
                        self.emit("V"+args[1], args[2:])
                    elif args[0] == 'vr':
                        self.emit("readV"+args[1])
                elif cmd == MSG_INTERNAL:
                    pass
                else:
                    print("Unexpected command: ", cmd)
                    return self.disconnect()

    def VIRTUAL_READ(blynk, pin):
        class Decorator():
            def __init__(self, func):
                self.func = func
                blynk.callbacks["readV"+str(pin)] = func
            def __call__(self):
                return self.func()
        return Decorator

    def VIRTUAL_WRITE(blynk, pin):
        class Decorator():
            def __init__(self, func):
                self.func = func
                blynk.callbacks["V"+str(pin)] = func
            def __call__(self):
                return self.func()
        return Decorator

import socket

class Blynk(BlynkProtocol):
    def __init__(self, auth, **kwargs):
        BlynkProtocol.__init__(self, auth, **kwargs)

    def connect(self):
        try:
            self.conn = socket.socket()
            self.conn.connect(socket.getaddrinfo("blynk-cloud.com", 80)[0][4])
            self.conn.settimeout(0.05)
            BlynkProtocol.connect(self)
        except:
            raise ValueError('connection with the Blynk servers failed')

    def _send(self, data):
        self.conn.send(data)
        # TODO: handle disconnect

    def run(self):
        data = b''
        try:
            data = self.conn.recv(self.buffin)
        except KeyboardInterrupt:
            raise
        except: # TODO: handle disconnect
            pass
        self.process(data)