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")

class Database:
    
    def __init__(self):
        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")
        self.client = InfluxDBClient(host, port, username, password, database)

    def log_data(self, msgdb, 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)
                    }
                }
            ]
            self.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)
                    }
                }
            ]
            self.client.write_points(json_body)


class CanBus:
    
    def __init__(self, database):
        
        self.database = database

        self.dev = socketcan.SocketCanDev("can0")
        
        parser = jsondb.JsonDbParser()
        self.msgdb = parser.parse('hydrobot_can.json')
        
        self.temp_msg = self.msgdb.AirSense
        self.relay_msg = self.msgdb.RelayDriveIn
        self.relay_send_msg = self.msgdb.RelayDriveOut
        
    def start(self):
        self.dev.start()
        
    def start_receive(self):
        _thread.start_new_thread(self.process_can, ())

    def process_can(self):
        while True:
            frame = self.dev.recv()
            message = self.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)
                    self.database.log_data(self.msgdb, message)
                
    def send_can(self):
        self.relay_send_msg.Nothing.value = 0
        self.relay_send_msg.Output1.value = 0
        self.relay_send_msg.Output2.value = 0
        self.relay_send_msg.Output3.value = 0
        self.relay_send_msg.Output4.value = 0
        if DEBUG_CAN:
            print("Send CAN message! ID: " + hex(self.relay_send_msg.id))
        if DEBUG_CAN_DETAIL:
            print(self.relay_send_msg)
        self.dev.send(self.relay_send_msg.encode())
    

def main():
    
    database = Database()
    canbus = CanBus(database)
    canbus.start()
    canbus.start_receive()

    while True:
        
        canbus.send_can()
        time.sleep(1)
        

if __name__ == "__main__":
    main()