from __future__ import print_function
import os
import glob
import datetime
from shutil import copyfile
try:
    import RPi.GPIO as GPIO
except:
    pass
import subprocess
import numpy as np
import matplotlib.pyplot as plt
from time import sleep, time
from os import system
from sys import stdout
from IPython import embed

from uldaq import (get_daq_device_inventory, DaqDevice, AInScanFlag, ScanStatus,
                   ScanOption, create_float_buffer, InterfaceType, AiInputMode)

def GPIO_setup(LED1_pin, LED2_pin, Button1_pin, Button2_pin, power_controll_pin):
    # LED output pins
    GPIO.setmode(GPIO.BOARD)

    GPIO.setup(LED1_pin, GPIO.OUT)  # 1
    GPIO.output(LED1_pin, GPIO.LOW)
    GPIO.setup(LED2_pin, GPIO.OUT)  # 2
    GPIO.output(LED2_pin, GPIO.HIGH)

    LED_status = [False, True]

    # switch controlled input
    # GPIO.setup(Button1_pin, GPIO.IN)
    GPIO.setup(power_controll_pin, GPIO.IN)

    GPIO.setup(Button1_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
    GPIO.setup(Button2_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

    return LED_status


def read_cfg(cfg_file, now, init_read=False):
    cfg_f = open(cfg_file, 'r+')
    cfg = cfg_f.readlines()

    ### read cfg information ###
    if init_read:
        for line in cfg:
            if "PathFormat" in line:
                path_format = ':'.join(line.split(':')[1:]).strip().replace('"', '').replace("'", "")
                cfg_f.close()
                return path_format

    rec_mode = 'standalone'
    for line in cfg:
        if 'Columns1' in line:
            n_cols = int(line.split(':')[1].strip())
        elif 'RecordMode1' in line:
            rec_mode = str(line.split(':')[1].strip())
        elif 'Rows1' in line:
            n_rows = int(line.split(':')[1].strip())
        elif "AISampleRate" in line:
            samplerate = int(float(line.split(':')[-1].strip().replace('kHz', '')) * 1000)
        elif "AIMaxVolt" in line:
            max_v = float(line.split(':')[1].strip().replace('mV', ''))
        elif 'Gain' in line:
            gain = int(line.split(':')[1].strip())

    channels = n_rows * n_cols

    ### alter information and re-write ###
    for enu, line in enumerate(cfg):
        if "StartDate" in line:
            cfg[enu] = ('          StartDate        : %s\n' % now.strftime('%Y-%m-%d'))
        elif "StartTime" in line:
            cfg[enu] = ('          StartTime        : %s\n' % (now.strftime('%H:%M:%S') + now.strftime(".%f")[:4]))
    cfg_f.close()

    cfg_f = open(cfg_file, 'w+')
    for line in cfg:
        cfg_f.write(line)
    cfg_f.close()

    return channels, samplerate, n_cols, n_rows, max_v, gain, rec_mode


def main():
    now = datetime.datetime.now()

    # get init cfg
    if os.path.exists('/media/pi/data1'):
        init_path = '/media/pi/data1'
    else:
        init_path = '/home/raab/data/rasp_test'

    init_cfgfile = os.path.join(init_path, 'fishgrid.cfg')
    if os.path.exists(init_cfgfile):
        path_format = read_cfg(init_cfgfile, now, init_read = True)
    else:
        print('cfg file missing !!!')
        quit()

    # create save folder and copy cfg file
    path = os.path.join(init_path, now.strftime(path_format))
    os.makedirs(path)
    copyfile(os.path.join(os.path.split(path)[0], 'fishgrid.cfg'), os.path.join(path, 'fishgrid.cfg'))
    cfgfile = os.path.join(path, 'fishgrid.cfg')

    # read and edit config file
    channels, rate, n_cols, n_rows, max_v, gain, rec_mode = read_cfg(init_cfgfile, now)

    file = os.path.join(path, 'traces-grid1.raw')
    temp_file = os.path.join(path, 'temperatures.csv')

    record_temp = False
    w1_bus_path = glob.glob('/sys/bus/w1/devices/28*/w1_slave')
    if len(w1_bus_path) > 0:
        w1_bus_path = w1_bus_path[0]
        record_temp = True
    f = open(file, 'wb')
    temp_f = open(temp_file, 'w')
    temp_f.write('%-6s; %-7s\n' % ('time/s', 'T/C'))

    # f.close()

    LED1_pin = 11
    LED2_pin = 13
    Button1_pin = 16
    Button2_pin = 18
    power_controll_pin = 37

    LED_status = GPIO_setup(LED1_pin, LED2_pin, Button1_pin, Button2_pin, power_controll_pin)

    last_button_1_t = time()
    last_button_2_t = time()

    # DAQ setup
    if True:
        # channels = 16

        status = ScanStatus.IDLE

        descriptor_index = 0  # ToDo: ????
        range_index = 0  # ToDo: ????

        interface_type = InterfaceType.USB
        low_channel = 0
        high_channel = channels

        samples_per_channel = rate * 20  # * channels = Buffer size
        # rate = 20000
        scan_options = ScanOption.CONTINUOUS

        if rec_mode == 'slave':
            scan_options |= ScanOption.EXTCLOCK

        flags = AInScanFlag.DEFAULT

        # Get descriptors for all of the available DAQ devices.
        devices = get_daq_device_inventory(interface_type)
        number_of_devices = len(devices)
        if number_of_devices == 0:
            raise Exception('Error: No DAQ devices found')

        print('Found', number_of_devices, 'DAQ device(s):')
        for i in range(number_of_devices):
            print('  ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='')

        # Create the DAQ device object associated with the specified descriptor index.
        daq_device = None
        daq_device = DaqDevice(devices[descriptor_index])

        # Get the AiDevice object and verify that it is valid.
        ai_device = None
        ai_device = daq_device.get_ai_device()
        if ai_device is None:
            raise Exception('Error: The DAQ device does not support analog input')

        # Verify that the specified device supports hardware pacing for analog input.
        ai_info = ai_device.get_info()
        if not ai_info.has_pacer():
            raise Exception('\nError: The specified DAQ device does not support hardware paced analog input')

        # Establish a connection to the DAQ device.
        descriptor = daq_device.get_descriptor()
        print('\nConnecting to', descriptor.dev_string, '- please wait...')
        daq_device.connect()

        # The default input mode is SINGLE_ENDED.
        input_mode = AiInputMode.SINGLE_ENDED
        # If SINGLE_ENDED input mode is not supported, set to DIFFERENTIAL.
        if ai_info.get_num_chans_by_mode(AiInputMode.SINGLE_ENDED) <= 0:
            input_mode = AiInputMode.DIFFERENTIAL

        # Get the number of channels and validate the high channel number.
        number_of_channels = ai_info.get_num_chans_by_mode(input_mode)
        if high_channel >= number_of_channels:
            high_channel = number_of_channels - 1
        channel_count = high_channel - low_channel + 1

        # Get a list of supported ranges and validate the range index.
        ranges = ai_info.get_ranges(input_mode)
        int_ranges = []
        for r in ranges:
            int_ranges.append(int(r.name.replace('BIP', '').replace('VOLTS', '')))

        for idx in np.argsort(int_ranges):
            if max_v * gain / 1000 <= int_ranges[idx]:
                range_index = idx
                break
        print(ranges[range_index])

        # Allocate a buffer to receive the data.
        data = create_float_buffer(channel_count, samples_per_channel)
        # system('clear')

        # Start the acquisition.
        rate = ai_device.a_in_scan(low_channel, high_channel, input_mode, ranges[range_index], samples_per_channel,
                                   rate, scan_options, flags, data)
        last_idx = 0
        # f = open('/media/pi/data1/test_file.raw', 'wb')


    # LED on when here ... wait for switch to start data aquisition
    GPIO.output(LED1_pin, GPIO.HIGH)
    LED_status[0] = True
    while GPIO.input(Button1_pin) == GPIO.LOW:
        sleep(.1)
    GPIO.output(LED1_pin, GPIO.LOW)
    LED_status[0] = False

    sleep(2)

    emergency_LED_t = time()
    emergency_LED_interval = 0.5


    LED_t = time()
    LED_t_interval = 2

    temp_t0 = time()
    next_temp_t = 0
    temp_interval = 300  # sec --> 5 min

    disp_eth_power = True

    while GPIO.input(Button1_pin) == GPIO.LOW:
        if record_temp == True:
            if time() - temp_t0 > next_temp_t:
                w1_f = open(w1_bus_path, 'r')
                w1_file = w1_f.readlines()
                for line in w1_file:
                    if 't=' in line:
                        temp = float((line.split('=')[-1].strip())) / 1000
                        temp_f.write('%6.0f; %7.3f\n' % (next_temp_t, temp))
                        temp_f.flush()
                        break

                w1_f.close()
                next_temp_t += temp_interval

        # blinking LED
        if time() - LED_t < .1 and LED_status[0] == False:
            LED_status[0] = True
            GPIO.output(LED1_pin, GPIO.HIGH)
        if time() - LED_t >= .1 and LED_status[0] == True:
            LED_status[0] = False
            GPIO.output(LED1_pin, GPIO.LOW)
        if time() - LED_t >= LED_t_interval:
            LED_t = time()
            

        # dist & eth0 controll
        if GPIO.input(Button2_pin) == GPIO.HIGH and (time() - last_button_2_t) > 5:
            if disp_eth_power == True:
                subprocess.run(['tvservice', '-o'])
                subprocess.run(['vcgencmd', 'display_power', '0'])

                subprocess.run(['sudo', 'ip', 'link', 'set', 'eth0', 'down'])
                GPIO.output(LED2_pin, GPIO.LOW)
                disp_eth_power = False
                last_button_2_t = time()

            elif disp_eth_power == False:
                subprocess.run(['tvservice', '-p'])
                subprocess.run(['vcgencmd', 'display_power', '1'])
                subprocess.run(['sudo', '/bin/chvt', '6'])
                subprocess.run(['sudo', '/bin/chvt', '7'])

                subprocess.run(['sudo', 'ip', 'link', 'set', 'eth0', 'up'])
                GPIO.output(LED2_pin, GPIO.HIGH)
                disp_eth_power = True
                last_button_2_t = time()

        # Get the status of the background operation
        status, transfer_status = ai_device.get_scan_status()

        index = transfer_status.current_index

        if index < 0 or index == last_idx:
            continue

        if index > last_idx:
            (np.array(data[last_idx:index], dtype=np.float32) / gain).tofile(f)
        else:
            (np.array(data[last_idx:], dtype=np.float32) / gain).tofile(f)
            (np.array(data[:index], dtype=np.float32) / gain).tofile(f)
            f.flush()

        last_idx = index

    f.close()
    temp_f.close()

    if LED_status[0] == False:
        GPIO.output(LED1_pin, GPIO.HIGH)
    if LED_status[1] == False:
        GPIO.output(LED2_pin, GPIO.HIGH)

    sleep(2)

    if daq_device:
        # Stop the acquisition if it is still running.
        if status == ScanStatus.RUNNING:
            ai_device.scan_stop()
        if daq_device.is_connected():
            daq_device.disconnect()
        daq_device.release()

    if disp_eth_power == False:
        subprocess.run(['tvservice', '-p'])
        subprocess.run(['vcgencmd', 'display_power', '1'])
        subprocess.run(['sudo', '/bin/chvt', '6'])
        subprocess.run(['sudo', '/bin/chvt', '7'])

        # subprocess.run(['sudo', 'ip', 'link', 'set', 'eth0', 'up'])
    GPIO.cleanup()


if __name__ == '__main__':
    main()