import time
import machine
import utime
from umqtt.simple import MQTTClient
from machine import RTC,I2C
import ssd1306
import micropython
import esp
import uasyncio
import gc
import ubinascii
import sys
import onewire, ds18x20
import mqtt_cfg

try:
  import urequests as requests
except:
  import requests

bStartup = True
gc.collect()
esp.osdebug(None)


gpioNum = 22
sTemp = machine.Pin(gpioNum)
ds = ds18x20.DS18X20(onewire.OneWire(sTemp))
tSensors = ds.scan()
displayActive = False
oled_width = 128
oled_height = 32

try:
    i2c = I2C(0,scl=machine.Pin(19),sda=machine.Pin(21))
    display=ssd1306.SSD1306_I2C(oled_width,oled_height,i2c)
    oled=ssd1306.SSD1306_I2C(oled_width,oled_height,i2c)
    display.fill(0)
    display.text("Init...",12,10)
    display.show()
    displayActive = True
except:
    pass

def scroll_screen_in_out(screen):
  for i in range (0, (oled_width+1)*2, 1):
    for line in screen:
      display.text(line[2], -oled_width+i, line[1])
    display.show()
    if i!= oled_width:
      display.fill(0)

def scroll_in_screen_v(screen):
    for i in range (0, (oled_height+1), 1):
        for line in screen:
            oled.text(line[2], line[0], -oled_height+i+line[1])
        oled.show()
        if i!= oled_height:
            oled.fill(0)

def scroll_in_screen_vo(screen):
    for line in screen:
        oled.text(line[2], line[0], -oled_height+line[1])
    oled.show()
    scroll_out_screen_vu(2)
    utime.sleep(1)
    scroll_out_screen_v(2)
    

def scroll_in_screen_vu(screen):
    for i in range (0, (oled_height+1), 1):
        for line in screen:
            iPos= oled_height-i+line[1]
            oled.text(line[2], line[0], iPos)
        oled.show()
        if i!= 0:
            oled.fill(0)

def scroll_out_screen_v(speed):
    for i in range ((oled_height+1)/speed):
        for j in range (oled_width):
            oled.pixel(j, i, 0)
        oled.scroll(0,speed)
        oled.show()

def scroll_out_screen_vu(speed):
    for i in range ((oled_height+1)/speed):
        for j in range (oled_width):
            oled.pixel(j, i, 0)
        oled.scroll(0,-speed)
        oled.show()

def _to_romcode_string(bytearray_romcode):
    string_hex_list = [str(ubinascii.hexlify(bytes([el])), 'utf8') for el in bytearray_romcode]
    romcode_str = ''.join(string_hex_list)
    return romcode_str

def getTempNow(sDevice):
    ds.convert_temp()
    return ds.read_temp(sDevice)

def get_id():
    url = 'https://www.uuidtools.com/api/generate/v4'
    response = requests.get(url)
    if response.status_code == 200:
        uid = response.text[2:-2]
        print("UID = %s" % uid)
        return uid
    else:
        print('Error')
        print(response.text)  
        return '_n_a'

def get_localtime(bFromNtp=False):
    if bFromNtp:
        import ntptime
        ntptime.settime()
    else:
        url = 'http://worldtimeapi.org/api/timezone/Europe/Brussels.txt'
        response = requests.get(url)
        if response.status_code == 200:
            dtDict = response.text.split('\n')
            now = dtDict[2].split(':',1)[1].strip()
            dow = dtDict[3].split(':')[1].strip()
            datePart, timePart = now.split('T')
            year = int(datePart.split('-')[0])
            month = int(datePart.split('-')[1])
            day = int(datePart.split('-')[2])
            hour = int(timePart.split(':')[0])
            minute = int(timePart.split(':')[1])
            second = int(timePart.split(':')[2].split('.')[0])
            subsecond = int(timePart.split('.')[1].split('+')[0])    
            rtc = RTC()
            rtc.init((year,month,day,dow,hour,minute,second,subsecond))
        else:
            print('Error')
            print(response.text)

def connect_mqtt(client_id, host, port, user, password):
    pub_client = MQTTClient(client_id, host, port=port,user=user,password=password,keepalive=60 )
    pub_client.connect()
    print('Connected to public %s MQTT broker' % (host))
    return pub_client

def restart_and_reconnect():
    print('Failed to connect to MQTT broker. Reconnecting...')
    utime.sleep_ms(15)
    if displayActive:
        try:
            display.init_display()
        except:
            pass
    #machine.reset()
  

async def run():
    last_message = 0
    message_interval = mqtt_cfg.message_interval
    print("Syncing local time...", end='')
    try:
        get_localtime(bFromNtp=False)
    except:
        try:
            get_localtime(bFromNtp=False)
        except:
            restart_and_reconnect()
    print("done.")
    print("Generating client ID...", end='')
    pub_client_id = 'FamClaes_%s_%s' % (get_id(),ubinascii.hexlify(machine.unique_id()).decode())
    print(pub_client_id)
    print('Start publishing...')
    bStartup = True
    dctClients={}
    for srvMosq in mqtt_cfg.activeServers:
        try:
            cMqtt = mqtt_cfg.MQTTServers[srvMosq]
            pub_client = connect_mqtt(client_id=pub_client_id, host=cMqtt['host'], port=cMqtt['port'],user=cMqtt['user'] ,password=cMqtt['passwd'])
            dctClients[srvMosq] = pub_client
        except:
            print("Cannot get connected to: %s" % cMqtt['host'])
            sys.exit(50)
    now = utime.localtime()
    ts = "{:02d}/{:02d}/{} {:02d}:{:02d}:{:02d}".format(now[2],now[1],now[0],now[3],now[4],now[5])
    tSensors = ds.scan()
    for s in tSensors:
        aRomCode = _to_romcode_string(s)
        print ('Found sensor: %s' % aRomCode)
    while True:
        #Niet elke keer chekcen voor additionele sensors? Mss om de 30 minuten? Of mss enkel bij reboot?
        screen1_row1 = "IP:%s" %(station.ifconfig()[0])
        screen1_row2 = "Mask:%s" %(station.ifconfig()[1])
        screen2_row1 = "{:02d}/{:02d}/{}".format(now[2],now[1],now[0])
        screen2_row2 = "{:02d}:{:02d}:{:02d}".format(now[3],now[4],now[5])
        screen1 = [[0, 12 , screen1_row1], [0, 22, screen1_row2]]
        screen2 = [[0, 12, screen2_row1], [0, 22, screen2_row2]]
        if displayActive:
            scroll_out_screen_v(2)
            scroll_in_screen_v(screen1)
            utime.sleep(2)
            scroll_out_screen_v(2)
            scroll_in_screen_v(screen2)
        if (time.time() - last_message) > message_interval or bStartup == True:
            if bStartup:
                bStartup = False
            tSensors = ds.scan()
            ts = "{:02d}/{:02d}/{} {:02d}:{:02d}:{:02d}".format(now[2],now[1],now[0],now[3],now[4],now[5])
            tSensors = ds.scan()
            for s in tSensors:
                aRomCode = _to_romcode_string(s)
                #print ('Found sensor: %s' % aRomCode)
                tempCelcius = str(getTempNow(s))
                screen3_row1 = aRomCode
                screen3_row2 = "%s deg." %(tempCelcius)
                screen3 = [[0, 12, screen3_row1], [0, 22, screen3_row2]]
                if displayActive:
                    utime.sleep(2)
                    scroll_out_screen_v(2)
                    scroll_in_screen_v(screen3)
                for srvMosq in mqtt_cfg.activeServers:
                    try:
                        cMqtt = mqtt_cfg.MQTTServers[srvMosq]
                        topic_pub = b"%s/temperature/%s" % (cMqtt['topic'],aRomCode)
                        topic_pub_ts = b"%s/timestamp/%s" % (cMqtt['topic'],aRomCode)
                        dctClients[srvMosq].publish(topic=topic_pub, msg=tempCelcius, retain=False, qos=0 )
                        print('Published %s for %s on %s' % (tempCelcius, topic_pub,cMqtt['host']))
                        dctClients[srvMosq].publish(topic=topic_pub_ts, msg=ts, retain=False, qos=0 )
                        print('Published %s for %s on %s' % (ts, topic_pub_ts,cMqtt['host']))
                    except Exception as e:
                        print("!! Publishing to %s was NOT successfull :-(" % cMqtt['host'] )
                        sys.print_exception(e)
                        restart_and_reconnect()
            utime.sleep(2)
            last_message = time.time()                       
            if displayActive:
                scroll_out_screen_v(2)
                scroll_in_screen_v(screen1)
                utime.sleep(2)
                scroll_out_screen_v(2)
                scroll_in_screen_v(screen2)
                utime.sleep(2)
                scroll_out_screen_v(2)
                scroll_in_screen_v(screen3)
            utime.sleep(2)

if __name__ == '__main__':
    try:
        uasyncio.run(run())
        oled.poweroff()
    except KeyboardInterrupt:
        if displayActive:
            oled.poweroff()
    except Exception as e:
        print ("Encountered error ", e.args, "...rebooting")
        sys.print_exception(e)    
        restart_and_reconnect()