import sys

import time

import _thread

import ast

import configparser

import datetime

from canard import can, messaging

from canard.hw import socketcan

from canard.file import jsondb

from canard.utils import queue

from influxdb import InfluxDBClient

from influxdb import SeriesHelper

from apscheduler.schedulers.background import BackgroundScheduler

import PID

from pytz import timezone

import logging

import signal

#TODO

#fix temperature offsets

#add periodic output refresh

# load config file

config = configparser.ConfigParser(allow_no_value = True)

config.read("hydrobot.conf")

# set up logger

logger = logging.getLogger('hydrobot')

log_level = config.get("system", "log_level")

levels = {"CRITICAL" : 50, "ERROR" : 40, "WARNING" : 30, "INFO" : 20, "DEBUG" : 10, "NOTSET" : 0}

logger.setLevel(levels[log_level])

fh = logging.FileHandler('hydrobot.log')

fh.setLevel(logging.INFO)

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(formatter)

logger.addHandler(fh)

logger.info("Starting HydroBot!")

class MySeriesHelper(SeriesHelper):

    # Meta class stores time series helper configuration.

    class Meta:

        # The client should be an instance of InfluxDBClient.

        #client = myclient

        # The series name must be a string. Add dependent fields/tags in curly brackets.

        series_name = '{measurement}'

        # Defines all the fields in this time series.

        fields = ['value']

        # Defines all the tags for the series.

        tags = ['measurement']

        # Defines the number of data points to store prior to writing on the wire.

        bulk_size = 5

        # autocommit must be set to True when using bulk_size

        autocommit = True

class Database:

    def __init__(self):

        host = config.get("database", "host")

        # To manually submit data points which are not yet written, call commit:

        #MySeriesHelper.commit()

    def log_data(self, msgdb, message):

        try:

            if message == msgdb.AirSense:

                MySeriesHelper(measurement='air_temp', value=(float)(message.Temperature.value))

                MySeriesHelper(measurement='air_humidity', value=(float)(message.Humidity.value))

                MySeriesHelper(measurement='air_pressure', value=(float)(message.Pressure.value))

            if message == msgdb.RelayDriveIn:

                MySeriesHelper(measurement='water_flow_rate', value=(float)(message.FlowRate.value))

                MySeriesHelper(measurement='input_1', value=(float)(message.Input1.value))

                MySeriesHelper(measurement='input_2', value=(float)(message.Input2.value))

                MySeriesHelper(measurement='input_3', value=(float)(message.Input3.value))

                MySeriesHelper(measurement='input_4', value=(float)(message.Input4.value))

            if message == msgdb.WaterSense:

                MySeriesHelper(measurement='water_level', value=(float)(message.PercentFull.value))

                MySeriesHelper(measurement='water_temp', value=(float)(message.Temperature.value))

        except:

            logger.error("Could not connect to database")

class CanBus:

        self.database = database

        self.queue = queue.CanQueue(self.dev)

        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.queue.start()

        _thread.start_new_thread(self.process_can, ())

    def process_can(self):

        while True:

            frame = self.queue.recv()

            if frame != None:

                message = self.msgdb.decode(frame)

                if message:

                    logger.debug("Received CAN message! ID: " + hex(message.id))

                    self.database.log_data(self.msgdb, message)

    def send_can(self):

        self.relay_send_msg.Nothing.value = 0

        if self.relay_send_msg.Output1.value == 0:

            self.relay_send_msg.Output1.value = 1

        self.apscheduler.get_job(timer_off).pause()

        logger.info("Turning " + timer_on + "!")

    def interval_on(self, module, output, timer_off, timer_on, off_duration):

        self.canbus.set_output(module, output, 0)

        self.apscheduler.get_job(timer_off).reschedule("interval", weeks = off_duration[0], days = off_duration[1], hours = off_duration[2], minutes = off_duration[3], seconds = off_duration[4])

        self.apscheduler.get_job(timer_off).resume()

        self.apscheduler.get_job(timer_on).pause()

        logger.info("Turning " + timer_off + "!")

    def process_PID(self, pid, module_out, signal_out, module_in, signal_in):

        msg = self.canbus.msgdb.lookup_message(module_in)

        input_reading = msg.lookup_signal(signal_in).value

        input_reading = 19

        pid_out = pid.Update(input_reading)

        if pid_out > 0:

            self.canbus.set_output(module_out, signal_out, 1)

            run_time = datetime.datetime.now() + datetime.timedelta(milliseconds=pid_out)

            self.apscheduler.add_job(self.canbus.set_output, "date", run_date=run_time, args=[module_out, signal_out, 0])

def func():

    print(1)

    database = Database()

    canbus.start()

    scheduler = Scheduler(canbus)

    scheduler.start()

    while True:

        time.sleep(0.001)

def close_program(signum, frame):

    logger.info("Closing now!")

    sys.exit(0)

signal.signal(signal.SIGINT, close_program)

if __name__ == "__main__":

[Unit]

Description=HydroBot Hydroponics Control Service

After=network.target

BindsTo=sys-subsystem-net-devices-%i.device

After=sys-subsystem-net-devices-%i.device

[Service]

WorkingDirectory=/opt/hydrobot-software

User=hydrobot

Group=hydrobot

[Install]

WantedBy=multi-user.target