# -*- coding: utf-8 -*-
"""
Created on Thu Mar 11 15:39:17 2021

@author: alain

$ cd ~/guitastro/gui/tp_audine_elec
$ python3 tp_audine_elec.py
"""

import os
import sys
import yaml
import subprocess
import time
from PIL import ImageTk, Image
import tkinter as tk
from tkinter import ttk
import tkinter.font as tkFont
import tkinter.scrolledtext as tkscrolled

import platform

path = os.path.abspath("../../src")
if path not in sys.path:
        sys.path.insert(0,path)
import guitastro

# #####################################################################
# #####################################################################
# #####################################################################
# Main
# #####################################################################
# #####################################################################
# #####################################################################

if __name__ == "__main__":

    # --- Get path_images for examples
    ima1 = guitastro.Ima()
    path_products = ima1.copy_data2products()

    # --- Global variable config for the YML file
    fconfig = os.path.join(path_products,"tp_audine_elec.yml")
    if not os.path.exists(fconfig):
        config = {}
        conf = {}
        conf["fits_path"] = "/home/user/Documents"
        config["visu1"] = conf
    else:
        with open(fconfig, 'r') as stream:
            try:
                config = yaml.safe_load(stream)
            except yaml.YAMLError as exc:
                print(exc)

    # --- Global variable to select the method
    methods = ["full_frame", "zi_zh", "fast_line", "read_pel_fast", "read_pel_fast2", "fast_vidage"] #, "square_signal", "set_0", "set_255"]

    # --- Global variable to define info messages
    infos = {}
    infos['demarrer_acq'] = "Appuyez sur le bouton Acquisition pour envoyer des signaux à la caméra"
    infos['acq_en_cours'] = "Acquisition en cours. Attendre quelques secondes... Prendre des mesures à l'oscilloscope"
    infos['acq_impossible'] = "Acquisition impossible sur cet OS. Utiliser un Raspberry PI"
    infos['bad_method'] = f"Method not found amonsgt {methods}"

    # --- Global variable for Tk variables
    var = {}
    var['executable'] = "/home/user/iut/tp_ccd/bin/Debug/tp_ccd"
    var['c_code_filename'] = os.path.join(os.getcwd(), "main.cpp")
    var['c_code_filename_alt'] = "main.cpp"
    var['image_path'] = "/home/user/Documents"
    var['image_filename'] = "image.fit"

    # ===================================================
    # ===================================================
    # Function definitions
    # ===================================================
    # ===================================================

    def save_config():
        global fconfig
        with open(fconfig, 'w') as yaml_file:
            yaml.dump(config, yaml_file, default_flow_style=False)

    def ima1_load():
        global widgets
        path_cur = config["visu1"]["fits_path"]
        ima1.rootdir = path_cur
        fullfile = ima1.load()
        if fullfile != "":
            path_new = os.path.dirname(fullfile)
            if path_cur != path_new and path_new != "":
                config["visu1"]["fits_path"] = path_new
                save_config()
        visu1.autocuts()
        visu1.disp()
        widgets["button_saveima_1"].configure(state= tk.NORMAL)

    def ima1_save():
        ima1.save()

    def acquisition():
        global widgets
        global infos
        global var
        global methods
        widgets["button_loadima_1"].configure(state= tk.DISABLED)
        widgets["button_saveima_1"].configure(state= tk.DISABLED)
        widgets["button_acq"].configure(state= tk.DISABLED)
        var['info'].set(infos['acq_en_cours'])
        # ---
        method = var_method.get()
        if method in methods:
            meth = method
        else:
            var['info'].set(infos['bad_method'])
            tkroot.update()
            time.sleep(5)
            var['info'].set(infos['demarrer_acq'])
            tkroot.update()
            return
        # ---
        expo = var_exp.get()
        if expo < 0:
            expo = 0
        if expo > 30:
            expo = 30
        var_exp.set(expo)
        # ---
        binn = var_bin.get()
        if binn < 1:
            binn = 1
        if binn > 100:
            binn = 100
        var_bin.set(binn)
        # ---
        tkroot.update()
        # ---
        argus = []
        argus.append(var['executable'])
        argus.append(f"{meth}")
        argus.append(f"{expo}")
        argus.append(f"{binn}")
        # --- Launch the acquisition process
        t0 = time.time()
        message = f'subprocess.run({argus},capture_output=True)'
        print(message)
        release = platform.release()
        image = False
        if "raspi" in release:
            # Launch the process only for Raspberry
            res = subprocess.run(argus, capture_output=True)
            stdo = res.stdout
            print(stdo)
            #lstdos = str(stdo).split("\\n")
            if meth == "full_frame":
                image = True
            else:
                time.sleep(1)
        else:
            var['info'].set(infos['acq_impossible'])
            tkroot.update()
            time.sleep(5)
        dt = time.time() - t0
        message = f"Acquisition done in {dt:.3f} sec"
        print(message)        # ---
        if meth=="full_frame" and image==True:
            time.sleep(0.5)
            fname = os.path.join(var['image_path'],var['image_filename'])
            fullfile = ima1.load(fname)
            path_new = os.path.dirname(fullfile)
            config["visu1"]["fits_path"] = path_new
            ima1.rootdir = path_new
            save_config()
	        # ---
            visu1.autocuts()
            visu1.disp()
        # ---
        widgets["button_loadima_1"].configure(state= tk.NORMAL)
        widgets["button_saveima_1"].configure(state= tk.NORMAL)
        widgets["button_acq"].configure(state= tk.NORMAL)
        var['info'].set(infos['demarrer_acq'])
        # --- update the plot
        tkroot.update()

    # ===================================================
    # ===================================================
    # Start main code
    # ===================================================
    # ===================================================

    # --- Create a Tk interface
    tkroot = tk.Tk()
    dimx = 1600
    dimy = 880
    geom = f"{dimx}x{dimy}+80+0"
    tkroot.geometry(geom)
    tkroot.title("TP CCD Electronique - BUT S5")
    tkroot.minsize(height=dimy, width=dimx)
    tkroot.maxsize(height=dimy+50, width=dimx+50)

    fontStyle_1 = tkFont.Font(family="Arial", size=14, weight="bold")
    fontStyle_2 = tkFont.Font(family="Arial", size=12, weight="bold")
    fontStyle_3 = tkFont.Font(family="Arial", size=10, weight="bold")
    fontStyle_c3 = tkFont.Font(family="courier", size=10, weight="bold")

    # ===================================================
    # ===================================================
    # Frame1. Acquisition button and image visu
    # ===================================================
    # ===================================================
    frame1 = tk.Frame(tkroot)

    # ---
    frame101 = tk.Frame(frame1)
    frame101.pack(side = tk.TOP, fill=tk.X, expand=tk.NO)
    # ---
    widgets = {}
    # ---
    frame101m = tk.Frame(frame101)
    # ---
    photo_logo = ImageTk.PhotoImage(file='logo_iut_mp.png')
    label1 = tk.Label(frame101m, image=photo_logo)
    label1.image = photo_logo
    label1.pack(side = tk.LEFT, padx=2)
    # ---
    var_method = tk.StringVar()
    var_method.set(methods[0])
    label_method = tk.Label(frame101m, text="Method")
    label_method.pack(side = tk.LEFT)
    entry_method = ttk.Combobox(frame101m, textvariable=var_method, width=12)
    entry_method['values'] = methods
    entry_method['state'] = 'readonly'
    entry_method.pack(side = tk.LEFT)
    #entry_method('<<ComboboxSelected>>', var_method)
    # ---
    var_exp = tk.DoubleVar()
    var_exp.set(0.0)
    label_exp = tk.Label(frame101m, text="Temps de pose (s)")
    label_exp.pack(side = tk.LEFT)
    entry_exp = tk.Entry(frame101m, width=4, textvariable=var_exp)
    entry_exp.pack(side = tk.LEFT)
    # ---
    var_bin = tk.IntVar()
    var_bin.set(1)
    label_bin = tk.Label(frame101m, text="Binning")
    label_bin.pack(side = tk.LEFT)
    entry_bin = tk.Entry(frame101m, width=4, textvariable=var_bin)
    entry_bin.pack(side = tk.LEFT)
    # ---
    widgets["button_acq"] = tk.Button(frame101m, text="Acquisition", command=acquisition, padx=20, pady=20, font='sans 16 bold')
    widgets["button_acq"].pack(side = tk.LEFT, pady=5, padx=5)
    # ---
    widgets["button_loadima_1"] = tk.Button(frame101m, text="Load FITS", command=ima1_load)
    widgets["button_loadima_1"].pack(side=tk.LEFT, padx = 2)
    widgets["button_saveima_1"] = tk.Button(frame101m, text="Save FITS", command=ima1_save, state= tk.DISABLED)
    widgets["button_saveima_1"].pack(side=tk.LEFT, padx = 2)
    frame101m.pack(side = tk.TOP, fill=tk.X, expand=tk.NO)

    # ---
    frame102 = tk.Frame(frame1)
    # ---
    var['info'] = tk.StringVar()
    var['info'].set(infos['demarrer_acq'])
    widgets["label_info"] = tk.Label(frame102, textvariable=var['info'], padx = 10)
    widgets["label_info"].pack(side = tk.LEFT)
    frame102.pack(side = tk.TOP, fill=tk.X, expand=tk.NO)

    # --- Create and use a visu
    try:
        frame101i = tk.Frame(frame1)
        visu1 = guitastro.Visu(frame101i)
        visu1.ima(ima1)
        frame101i.pack(side = tk.TOP, fill=tk.BOTH, expand=tk.YES)
    except:
        msg = "{}".format(sys.exc_info())
        print(msg)

    frame1.pack(fill=tk.Y, side = tk.LEFT, anchor=tk.NW)

    # ===================================================
    # ===================================================
    # Frame2. Display C code
    # ===================================================
    # ===================================================
    frame2 = tk.Frame(tkroot)

    label_code = tk.Label(frame2, text="C code run by the button Acquisition")
    label_code.pack(side = tk.TOP)

    frame_display_code = tk.Frame(frame2)

    scrollbar = tk.Scrollbar(frame_display_code)
    text_code_txt = tk.Text(frame_display_code, height=15, wrap="word", yscrollcommand=scrollbar.set, font=fontStyle_3)

    scrollbar.config(command=text_code_txt.yview)
    scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

    text_code_txt.tag_config('red', foreground="red")
    text_code_txt.tag_config('blue', foreground="blue")
    text_code_txt.tag_config('black', foreground="black")
    text_code_txt.tag_config('green', foreground="green")
    lignes = ""
    try:
        with open(var['c_code_filename'], "rt") as fid:
            lignes = fid.readlines()
    except:
        with open(var['c_code_filename_alt'], "rt") as fid:
            lignes = fid.readlines()
    for ligne in lignes:
        text_code_txt.insert(tk.END, ligne, "blue")
    text_code_txt.yview_moveto(1.0)
    text_code_txt.pack(side = tk.TOP, padx=5, pady=1)
    frame_display_code.pack(side = tk.TOP, pady=5)

    notebook = ttk.Notebook(frame2)
    tab201 = ttk.Frame(notebook)
    tab202 = ttk.Frame(notebook)
    tab203 = ttk.Frame(notebook)
    tab204 = ttk.Frame(notebook)
    tab205 = ttk.Frame(notebook)
    tab206 = ttk.Frame(notebook)
    tab207 = ttk.Frame(notebook)

    # =====================================================
    # Tab 201 ==
    # =====================================================
    frame_display_ccdphase = tk.Frame(tab201)
    image = Image.open('true2phase_ccd.png')
    zoom = 1.2
    image_size = tuple([int(zoom * x)  for x in image.size])
    ccdphase_canvas = tk.Canvas(frame_display_ccdphase, width=image_size[0], height=image_size[1], relief=tk.RAISED, cursor="crosshair")
    ccdphase_image = ImageTk.PhotoImage(image.resize(image_size))
    ccdphase_canvas.create_image(0, 0, anchor = tk.NW, image = ccdphase_image)
    ccdphase_canvas.pack()
    frame_display_ccdphase.pack()

    # =====================================================
    # Tab 202 ==
    # =====================================================
    frame_display_ccdtransf = tk.Frame(tab202)
    image = Image.open('ccd_transferts1.png')
    zoom = 2
    image_size = tuple([int(zoom * x)  for x in image.size])
    ccdtransf_canvas = tk.Canvas(frame_display_ccdtransf, width=image_size[0], height=image_size[1], relief=tk.RAISED, cursor="crosshair")
    ccdtransf_image = ImageTk.PhotoImage(image.resize(image_size))
    ccdtransf_canvas.create_image(0, 0, anchor = tk.NW, image = ccdtransf_image)
    ccdtransf_canvas.pack()
    frame_display_ccdtransf.pack()

    # =====================================================
    # Tab 203 ==
    # =====================================================
    frame_display_timing = tk.Frame(tab203)
    image = Image.open('timing_diagram1.png')
    zoom = 0.75
    image_size = tuple([int(zoom * x)  for x in image.size])
    timing_canvas = tk.Canvas(frame_display_timing, width=image_size[0], height=image_size[1], relief=tk.RAISED, cursor="crosshair")
    timing_image = ImageTk.PhotoImage(image.resize(image_size))
    timing_canvas.create_image(0, 0, anchor = tk.NW, image = timing_image)
    timing_canvas.pack()
    frame_display_timing.pack()

    # =====================================================
    # Tab 204 ==
    # =====================================================
    frame_display_pins = tk.Frame(tab204)
    image = Image.open('pins_raspberry.png')
    zoom = 0.75
    image_size = tuple([int(zoom * x)  for x in image.size])
    pins_canvas = tk.Canvas(frame_display_pins, width=image_size[0], height=image_size[1], relief=tk.RAISED, cursor="crosshair")
    pins_image = ImageTk.PhotoImage(image.resize(image_size))
    pins_canvas.create_image(0, 0, anchor = tk.NW, image = pins_image)
    pins_canvas.pack()
    frame_display_pins.pack()

    # =====================================================
    # Tab 205 ==
    # =====================================================
    frame_display_ccd = tk.Frame(tab205)
    image = Image.open('ccd.png')
    zoom = 0.65
    image_size = tuple([int(zoom * x)  for x in image.size])
    ccd_canvas = tk.Canvas(frame_display_ccd, width=image_size[0], height=image_size[1], relief=tk.RAISED, cursor="crosshair")
    ccd_image = ImageTk.PhotoImage(image.resize(image_size))
    ccd_canvas.create_image(0, 0, anchor = tk.NW, image = ccd_image)
    ccd_canvas.pack()
    frame_display_ccd.pack()

    # =====================================================
    # Tab 206 ==
    # =====================================================
    frame_display_ampli = tk.Frame(tab206)
    image = Image.open('ampli.png')
    zoom = 0.60
    image_size = tuple([int(zoom * x)  for x in image.size])
    ampli_canvas = tk.Canvas(frame_display_ampli, width=image_size[0], height=image_size[1], relief=tk.RAISED, cursor="crosshair")
    ampli_image = ImageTk.PhotoImage(image.resize(image_size))
    ampli_canvas.create_image(0, 0, anchor = tk.NW, image = ampli_image)
    ampli_canvas.pack()
    frame_display_ampli.pack()

    # =====================================================
    # Tab 207 ==
    # =====================================================
    frame_display_can = tk.Frame(tab207)
    image = Image.open('can.png')
    zoom = 0.65
    image_size = tuple([int(zoom * x)  for x in image.size])
    can_canvas = tk.Canvas(frame_display_can, width=image_size[0], height=image_size[1], relief=tk.RAISED, cursor="crosshair")
    can_image = ImageTk.PhotoImage(image.resize(image_size))
    can_canvas.create_image(0, 0, anchor = tk.NW, image = can_image)
    can_canvas.pack()
    frame_display_can.pack()

    # =====================================================
    # Pack frame of tabs
    # =====================================================
    notebook.add(tab201, text="CCD 2 phases")
    notebook.add(tab202, text="CCD transferts")
    notebook.add(tab203, text="Timings")
    notebook.add(tab204, text="Raspberry pins")
    notebook.add(tab205, text="CCD chip")
    notebook.add(tab206, text="Analogic output")
    notebook.add(tab207, text="CAN and multiplexer")
    notebook.pack(fill = tk.Y)

    frame2.pack(fill = tk.Y, side=tk.LEFT, anchor="nw")

    # ===================================================
    # --- Launch the event loop of the user interface
    # ===================================================
    tkroot.pack_propagate(0)
    tkroot.update()
    tkroot.mainloop()