import sys
import time
import _thread
from canard import can, bus
from canard.hw import socketcan
from canard.file import jsondb
from influxdb import InfluxDBClient
import configparser

config = configparser.ConfigParser()
config.read("config.txt")
DEBUG_CAN = config.getboolean("debug", "can")
DEBUG_CAN_DETAIL = config.getboolean("debug", "can_detail")

def log_data(msgdb, client, message):
    if message == msgdb.AirSense:
        json_body = [
            {
                "measurement": "air_temp",
                "fields": {
                    "value": (float)(message.Temperature.value)
                }
            },
            {
                "measurement": "air_humidity",
                "fields": {
                    "value": (float)(message.Humidity.value)
                }
            },
            {
                "measurement": "air_pressure",
                "fields": {
                    "value": (float)(message.Pressure.value)
                }
            }
        ]
        client.write_points(json_body)
    if message == msgdb.RelayDriveIn:
        json_body = [
            {
                "measurement": "input_1",
                "fields": {
                    "value": (float)(message.Input1.value)
                }
            },
            {
                "measurement": "input_2",
                "fields": {
                    "value": (float)(message.Input2.value)
                }
            },
            {
                "measurement": "input_3",
                "fields": {
                    "value": (float)(message.Input3.value)
                }
            },
            {
                "measurement": "input_4",
                "fields": {
                    "value": (float)(message.Input4.value)
                }
            }
        ]
        client.write_points(json_body)
    

def process_can(dev, msgdb, client):
    while True:
        frame = dev.recv()
        message = msgdb.decode(frame)
        if message:
            for s in message._signals.values():
                if DEBUG_CAN:
                    print("Received CAN message! ID: " + hex(message.id))
                if DEBUG_CAN_DETAIL:
                    print(s)
                    print(s.value)
                log_data(msgdb, client, message)
                
def send_can(dev, msgdb, relay_send_msg):
    relay_send_msg.Nothing.value = 0
    relay_send_msg.Output1.value = 0
    relay_send_msg.Output2.value = 0
    relay_send_msg.Output3.value = 0
    relay_send_msg.Output4.value = 0
    if DEBUG_CAN:
        print("Send CAN message! ID: " + hex(relay_send_msg.id))
    if DEBUG_CAN_DETAIL:
        print(relay_send_msg)
    dev.send(relay_send_msg.encode())
    

def main():
    host = config.get("database", "host")
    port = config.get("database", "port")
    username = config.get("database", "username")
    password = config.get("database", "password")
    database = config.get("database", "database")
    client = InfluxDBClient(host, port, username, password, database)

    parser = jsondb.JsonDbParser()
    msgdb = parser.parse('hydrobot_can.json')
    temp_msg = msgdb.AirSense
    relay_msg = msgdb.RelayDriveIn
    relay_send_msg = msgdb.RelayDriveOut

    dev = socketcan.SocketCanDev("can0")
    dev.start()
    
    _thread.start_new_thread(process_can, (dev, msgdb, client))

    while True:
        
        send_can(dev, msgdb, relay_send_msg)
        time.sleep(1)
        

if __name__ == "__main__":
    main()