from PyQt5.QtCore import QThread, pyqtSignal, QSize, QTimer
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QLabel, QSizePolicy, QPushButton, QComboBox
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QFont

import serial
import re
import time
import matplotlib.pyplot as plt
import os
import struct
import requests
import subprocess

from datetime import datetime
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas

class UpdateWorker(QThread):
    update_signal = pyqtSignal(bool, int, float, float)
    data_received = pyqtSignal(str)
    stop_signal = pyqtSignal()
    mode_signal = pyqtSignal(int)
    offset_signal = pyqtSignal(int)
    apitimer_signal = pyqtSignal()
    change_color_signal = pyqtSignal(str, str, str)

    def __init__(self, serial_number, bench_id, port, block_id, main_app):
        super().__init__()
        print(f"id{bench_id}:\tport {port}")
        print(f"id{bench_id}:\tserial {serial_number}")
        self.block = self.add_block(serial_number, bench_id, port, block_id, main_app)
        self.main_app = main_app  # Store the reference to the BlockStackApp instance
        self.serial_number = serial_number
        self.bench_id = bench_id
        self.port = port
        self.block_id = block_id
        self.running = True
        self.position_value = 0.0
        self.diameter_total = 0.0 # for average calculation
        self.diameter_count = 0
        self.diameter_value = 0.0
        self.diameter_value1 = 0.0
        self.diameter_value2 = 0.0
        self.diameter_value3 = 0.0
        self.diameter_min = 0.0
        self.diameter_max = 0.0
        self.density = 1.0
        self.prepare_flag = False
        self.prepare_ok = False
        self.reset_flag = False
        self.ignore_stop = False
        self.is_running = False
        self.reset_data = False
        self.homed = False
        self.can_start = False
        self.current_job = None
        self.current_job = None
        self.data_list = []
        self.profile_data = {}  # Dictionary to store profile data

        # run at startup
        self.update_profiles()

        self.timer = QTimer()
        self.timer.timeout.connect(self.query_api)
        self.timer.start(3000)

    def run(self):
        try:
            with serial.Serial(self.port, 1000000, timeout=1) as ser:
                ser.write(b'a')
                ser.write(b'F')
                ser.write(b'i')
                ser.write(b' ')
                while self.running:
                    if ser.in_waiting > 0:
                        data = ser.readline().decode('utf-8').strip()
                        if data:
                            self.parse_data(data)
                            if self.reset_flag and self.prepare_flag:
                                if self.position_value > 100 and self.reset_flag:
                                    self.ignore_stop = True
                                    self.change_color_signal.emit(self.block_id, 'btn_prepare', "#5A5A5A")
                                    ser.write(b'R')
                                    self.prepare_flag = False
                                    if ((1.65 < self.diameter_value) and (self.diameter_value < 1.85)) or ((2.70 < self.diameter_value) and (self.diameter_value < 2.95)):
                                        self.prepare_ok = True
                                    else:
                                        self.prepare_ok = False
                                    if self.prepare_ok:
                                        self.change_color_signal.emit(self.block_id, 'btn_prepare', "#00A000")
                                        self.change_color_signal.emit(self.block_id, 'btn_start', "#A0A000")
                                    else:
                                        self.change_color_signal.emit(self.block_id, 'btn_prepare', "#A00000")
                                else:
                                    self.change_color_signal.emit(self.block_id, 'btn_prepare', "#0000FF")
                            else:
                                if data == '%STOP':
                                    self.stop_running()
                                    # if not self.ignore_stop:
                                    #     self.change_color_signal.emit(self.block_id, 'btn_start', "#A00000")
                                    #     self.is_running = False
                                    #     self.save_data_to_file()
                                    # else:
                                    #     self.ignore_stop = False
                                elif data == '$NOTHOMED':
                                    self.homed = False
                                    self.change_color_signal.emit(self.block_id, 'btn_home', "#a0a000")
                                elif data == '$HOMED':
                                    # print(f"id{self.bench_id} :\tHoming ok")
                                    self.homed = True
                                    self.change_color_signal.emit(self.block_id, 'btn_home', "#5a5a5a")
        except serial.SerialException as e:
            print(f"Error with port {self.port}: {e}")

    def save_data_to_file(self):
# format:
#
#   #bench: FDR1-proto0
#   #date: 20250224_232750
#   #spool: R587
#   #material: Enky PP Ortho V1-2106 20251007-00 N°7
#   d:1.730,dm:1.730,dM:1.730,p:0.000,s:0.0,m:1500.0000,q:3,ap:0/3598
#   d:1.730,dm:1.730,dM:1.730,p:2.291,s:0.0,m:1504.5000,q:3,ap:0/3598
#   d:1.750,dm:1.730,dM:1.750,p:6.021,s:0.0,m:1504.5000,q:3,ap:0/3598
#   d:1.730,dm:1.730,dM:1.750,p:11.192,s:0.0,m:1504.5000,q:3,ap:0/3598
#   d:1.730,dm:1.730,dM:1.750,p:17.999,s:0.0,m:1504.5000,q:3,ap:0/3598
#   d:1.730,dm:1.730,dM:1.750,p:26.049,s:0.0,m:1504.5000,q:3,ap:0/3598
#
# [...]
#
#   d:1.750,dm:1.690,dM:1.820,p:1614324.750,s:49.6,m:969.1023,q:2,ap:1180/3598
#   d:1.820,dm:1.690,dM:1.820,p:1614324.250,s:1.1,m:972.0096,q:2,ap:1180/3598
#   MOTOR DISABLED: FILAMENT OUT OF RANGE
#   #end: 20250224_232750


        print(f"id{self.bench_id}:\tsaving job: {self.current_job}")

        spool, vendor, material, batch, description, startstamp = self.current_job
        endstamp = datetime.now().strftime("%Y%m%d_%H%M%S")


        outfilename = os.path.join("data", f"{spool}_{startstamp}.fslp")


        with open(outfilename, "w") as outfile:
            outfile.write(F"#bench: {self.serial_number} (#{self.bench_id})\n")
            outfile.write(F"#date: {startstamp}\n")
            outfile.write(F"#spool: {spool}\n")
            outfile.write(F"#material: {vendor} {material} {batch} {description}\n")

            for ts, position, diameter in self.data_list:
                outfile.write(f"t:{ts},d:{diameter},p:{position}\n")

            outfile.write(F"#end: {endstamp}\n")

        subprocess.run(["gzip", "-9", outfilename])

        files = {'fsl': open(outfilename+'.gz', 'rb')}
        url = f"http://462filament/api.php?data=upload"

        r = requests.post(url, files=files)
        
    def parse_data(self, data):

        match = re.match(r"^[#d](\d):(-?[\d]+),p:(-?[\d\.]+)$", data)
        if match:
            diameter_int = int(match.group(2))
            if diameter_int<65000:
                dial_number = int(match.group(1))
                position_value = float(match.group(3))
                diameter_value = float(diameter_int)/1000

                if diameter_value < self.diameter_min: # process min/max
                    self.diameter_min = diameter_value
                if diameter_value > self.diameter_max:
                    self.diameter_max = diameter_value

                self.update_signal.emit(self.is_running, dial_number, diameter_value, position_value)
                self.reset_flag = True

        offset_match = re.match(r"^#h:(\d+)", data)
        if offset_match:
            home_offset = int(offset_match.group(1))
            # print(f"id{self.bench_id}:\tOffset: {home_offset:.2f}")
            self.block.btn_offset.setText(f"Offset: {home_offset:.2f}")

        mode_match = re.match(r"^#o:(\d+)", data)
        if mode_match:
            mode = int(mode_match.group(1))
            self.mode_signal.emit(mode)
            match mode:
                case 1:
                    self.change_color_signal.emit(self.block_id, 'btn_go_left', "#0000A0")
                    self.change_color_signal.emit(self.block_id, 'btn_go_right', "#5a5a5a")
                    self.change_color_signal.emit(self.block_id, 'btn_reset', "#5a5a5a")
                case 2:
                    self.change_color_signal.emit(self.block_id, 'btn_go_left', "#5a5a5a")
                    self.change_color_signal.emit(self.block_id, 'btn_go_right', "#0000A0")
                    self.change_color_signal.emit(self.block_id, 'btn_reset', "#5a5a5a")
                case 3:
                    self.change_color_signal.emit(self.block_id, 'btn_go_left', "#5a5a5a")
                    self.change_color_signal.emit(self.block_id, 'btn_go_right', "#5a5a5a")
                    self.change_color_signal.emit(self.block_id, 'btn_reset', "#00A0A0")
        else:
            self.mode_signal.emit(65535)
            self.change_color_signal.emit(self.block_id, 'btn_go_left', "#5a5a5a")
            self.change_color_signal.emit(self.block_id, 'btn_go_right', "#5a5a5a")
            self.change_color_signal.emit(self.block_id, 'btn_reset', "#5A5A5A")

    def send_command(self, command):
        try:
            with serial.Serial(self.port, 1000000, timeout=1) as ser:
                ser.write(command.encode())
        except serial.SerialException as e:
            print(f"Could not send command to port {self.port}: {e}")
    
    def int_to_two_bytes(self, value):
        if not (0 <= value <= 0xFFFF):
            raise ValueError("Value out of range for two bytes")

        two_bytes = struct.pack('>H', value)
        return two_bytes

    def set_limits(self, left, right):
        print(f"id{self.bench_id}:\tupdate limits to {left}+{right}")
        try:
            with serial.Serial(self.port, 1000000, timeout=1) as ser:
                ser.write(b'\x04')
                time.sleep(0.001)
                ser.write(self.int_to_two_bytes(left))
                time.sleep(0.003)
                ser.write(self.int_to_two_bytes(right))
                time.sleep(0.003)
                ser.write(b'\x04')
                time.sleep(0.001)
                ser.write(b'\x00')
                time.sleep(0.001)
        except serial.SerialException as e:
            print(f"Could not send command to port {self.port}: {e}")

    def set_prepare(self, prepare):
        self.position_value = 0
        self.prepare_flag = True
        self.reset_flag = False

    def start_running(self):
        if self.prepare_ok and self.can_start:
            self.reset_data = True
            self.is_running = True

            self.current_job = (
                    self.api_job['spool'],
                    self.api_job['vendor'],
                    self.api_job['material'],
                    self.api_job['batch'],
                    self.api_job['description'],
                    datetime.now().strftime("%Y%m%d_%H%M%S")
                )

            self.change_color_signal.emit(self.block_id, 'btn_start', "#00a000")
            self.change_color_signal.emit(self.block_id, 'btn_prepare', "#5A5A5A")
            
            self.send_command('S')

    def stop_running(self):
        if self.is_running:
            self.send_command('R')
            
            self.block.data_label.setText(
                    f"Job done, processing..."
                )
            
            # for position, diameter in self.data_list:
            #     print(f"{position} -> {diameter}")

            self.change_color_signal.emit(self.block_id, 'btn_start', "#a00000")
            self.change_color_signal.emit(self.block_id, 'btn_prepare', "#5A5A5A")
            
            self.is_running = False
            self.save_data_to_file()
            self.prepare_ok = False


    def clear_graph(self):
        self.line1.set_data([], [])
        self.line2.set_data([], [])
        self.line3.set_data([], [])
        self.canvas.draw()

    def add_block(self, serial_number, bench_id, port, block_id, main_app):
        block_widget = QWidget()
        block_layout = QHBoxLayout()
        block_layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)

        LABEL_SIZE = QSize(250, 20)
        BUTTON_SIZE = QSize(100, 25)
        VALUE_SIZE = QSize(80, 25)
        VALUEL_SIZE = QSize(25, 25)

        monospaced_font = QFont("unexistent", 10)
        monospaced_font.setStyleHint(QFont.Monospace)

        monospaced_bold_font = QFont("unexistent", 10)
        monospaced_bold_font.setStyleHint(QFont.Monospace)
        monospaced_bold_font.setBold(True)

        monospaced_italics_font = QFont("unexistent", 10)
        monospaced_italics_font.setStyleHint(QFont.Monospace)
        monospaced_italics_font.setItalic(True)

        left_layout = QVBoxLayout()
        data_label = QLabel("No API data")
        data_label.setTextFormat(Qt.RichText)
        data_label.setAlignment(Qt.AlignLeft | Qt.AlignTop)
        bench_label = QLabel(f"Bench ID: {bench_id}")
        bench_label.setToolTip(f"Serial number: {serial_number}\nCPU: Microchip PIC18F4431 @ 32 MHz\nPort: {port}\nBandwidth: 1 MBps\nPosition maxspd: 638 mm/s\nDiameter freq: ≈10.5 Hz")
        bench_label.setAlignment(Qt.AlignCenter)
        bench_label.setFixedSize(LABEL_SIZE)
        left_layout.addWidget(bench_label)
        left_layout.addWidget(data_label)

        left2_layout = QHBoxLayout()
        left2L_layout = QVBoxLayout()
        left2V_layout = QVBoxLayout()
        max_label = QLabel("2.000 ")
        max_label.setFont(monospaced_bold_font)
        avg_label = QLabel("2.0000")
        avg_label.setFont(monospaced_font)
        cur_label = QLabel("2.000 ")
        cur_label.setFont(monospaced_bold_font)
        len_label = QLabel("12345.00")
        len_label.setFont(monospaced_font)
        wht_label = QLabel("12.345 ")
        wht_label.setFont(monospaced_italics_font)
        min_label = QLabel("2.000 ")
        min_label.setFont(monospaced_bold_font)
        maxL_label = QLabel("∨")
        avgL_label = QLabel("⌀̄")
        curL_label = QLabel("⌀")
        lenL_label = QLabel("L")
        whtL_label = QLabel("M")
        minL_label = QLabel("∧")
        avg_label.setAlignment(Qt.AlignRight)
        max_label.setAlignment(Qt.AlignRight)
        cur_label.setAlignment(Qt.AlignRight)
        len_label.setAlignment(Qt.AlignRight)
        wht_label.setAlignment(Qt.AlignRight)
        min_label.setAlignment(Qt.AlignRight)

        avg_label.setToolTip("<i>Average diameter</i> in <b>mm</b>")
        max_label.setToolTip("<i>Maximum diameter</i> in <b>mm</b>")
        cur_label.setToolTip("<i>Current diameter</i> in <b>mm</b>")
        len_label.setToolTip("<i>Length</i> in <b>m</b>")
        wht_label.setToolTip("<i>Estimated mass</i> in <b>kg</b>")
        min_label.setToolTip("<i>Minimum diameter</i> in <b>mm</b>")

        maxL_label.setToolTip("<i>Average diameter</i> in <b>mm</b>")
        avgL_label.setToolTip("<i>Maximum diameter</i> in <b>mm</b>")
        curL_label.setToolTip("<i>Current diameter</i> in <b>mm</b>")
        lenL_label.setToolTip("<i>Length</i> in <b>m</b>")
        whtL_label.setToolTip("<i>Estimated mass</i> in <b>kg</b>")
        minL_label.setToolTip("<i>Minimum diameter</i> in <b>mm</b>")

        max_label.setFixedSize(VALUE_SIZE)
        avg_label.setFixedSize(VALUE_SIZE)
        cur_label.setFixedSize(VALUE_SIZE)
        len_label.setFixedSize(VALUE_SIZE)
        wht_label.setFixedSize(VALUE_SIZE)
        min_label.setFixedSize(VALUE_SIZE)

        maxL_label.setFixedSize(VALUEL_SIZE)
        avgL_label.setFixedSize(VALUEL_SIZE)
        curL_label.setFixedSize(VALUEL_SIZE)
        lenL_label.setFixedSize(VALUEL_SIZE)
        whtL_label.setFixedSize(VALUEL_SIZE)
        minL_label.setFixedSize(VALUEL_SIZE)

        left2V_layout.addWidget(max_label)
        left2V_layout.addWidget(avg_label)
        left2V_layout.addWidget(cur_label)
        left2V_layout.addWidget(len_label)
        left2V_layout.addWidget(wht_label)
        left2V_layout.addWidget(min_label)

        left2L_layout.addWidget(maxL_label)
        left2L_layout.addWidget(avgL_label)
        left2L_layout.addWidget(curL_label)
        left2L_layout.addWidget(lenL_label)
        left2L_layout.addWidget(whtL_label)
        left2L_layout.addWidget(minL_label)

        left2_layout.addLayout(left2L_layout)
        left2_layout.addLayout(left2V_layout)

        center_layout = QVBoxLayout()
        # graph_placeholder = QLabel("Graph Placeholder")
        # graph_placeholder.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored)
        # center_layout.addWidget(graph_placeholder)

        right_layout = QHBoxLayout()
        right_layout_1 = QVBoxLayout()
        right_layout_2 = QVBoxLayout()
        right_layout_3 = QVBoxLayout()

        btn_prepare = QPushButton("Prepare")
        btn_prepare.clicked.connect(lambda: self.send_command('P'))
        time.sleep(0.1)
        btn_prepare.clicked.connect(lambda: self.set_prepare(True))
        right_layout_1.addWidget(btn_prepare)

        btn_start = QPushButton("Start")
        btn_start.clicked.connect(self.start_running)
        right_layout_1.addWidget(btn_start)

        btn_reset = QPushButton("Reset/Zero")
        btn_reset.clicked.connect(lambda: self.send_command('r'))
        btn_reset.clicked.connect(lambda: self.change_color_signal.emit(self.block_id, 'btn_start', "#5A5A5A"))
        right_layout_1.addWidget(btn_reset)

        btn_stop = QPushButton("Stop")
        btn_stop.clicked.connect(self.stop_running)
        right_layout_1.addWidget(btn_stop)

        btn_spare1 = QPushButton()
        right_layout_1.addWidget(btn_spare1)



        btn_sleep = QPushButton("Sleep")
        btn_sleep.clicked.connect(lambda: self.send_command('a'))
        right_layout_2.addWidget(btn_sleep)

        btn_home = QPushButton("Home")
        btn_home.clicked.connect(lambda: self.send_command(' '))
        right_layout_2.addWidget(btn_home)

        btn_go_left = QPushButton("Go Left")
        btn_go_left.clicked.connect(lambda: self.send_command('1'))
        right_layout_2.addWidget(btn_go_left)

        btn_go_right = QPushButton("Go Right")
        btn_go_right.clicked.connect(lambda: self.send_command('2'))
        right_layout_2.addWidget(btn_go_right)

        btn_offset = QPushButton()
        right_layout_2.addWidget(btn_offset)

        btn_down_left = QPushButton("Offset +")
        btn_down_left.clicked.connect(lambda: self.send_command('b'))
        right_layout_3.addWidget(btn_down_left)

        btn_up_left = QPushButton("Offset -")
        btn_up_left.clicked.connect(lambda: self.send_command('n'))
        right_layout_3.addWidget(btn_up_left)

        btn_save_offset = QPushButton("Save Offset")
        btn_save_offset.clicked.connect(lambda: self.send_command('M'))
        right_layout_3.addWidget(btn_save_offset)



        dropd_profile = QComboBox()
        
        dropd_profile.addItem("Select a profile...")
        dropd_profile.model().item(0).setEnabled(False)

        
        dropd_profile.currentIndexChanged.connect(self.on_profile_changed)

        dropd_profile.setFixedWidth(120)
        
        view = dropd_profile.view()
        view.setMinimumWidth(350)  # Set the minimum width of the dropdown list

        right_layout_3.addWidget(dropd_profile)

        btn_update_profiles = QPushButton("Reload profiles")
        btn_update_profiles.clicked.connect(self.update_profiles)
        right_layout_3.addWidget(btn_update_profiles)


        right_layout.addLayout(right_layout_1)
        right_layout.addLayout(right_layout_2)
        right_layout.addLayout(right_layout_3)

        block_layout.addLayout(left_layout)
        block_layout.addLayout(left2_layout)
        block_layout.addLayout(center_layout)
        block_layout.addLayout(right_layout)

        block_widget.setLayout(block_layout)

        block_widget.btn_start = btn_start
        block_widget.btn_home = btn_home
        block_widget.btn_go_left = btn_go_left
        block_widget.btn_go_right = btn_go_right
        block_widget.btn_reset = btn_reset
        block_widget.btn_prepare = btn_prepare
        block_widget.data_label = data_label
        block_widget.bench_label = bench_label

        block_widget.max_label = max_label
        block_widget.avg_label = avg_label
        block_widget.dia_label = cur_label
        block_widget.len_label = len_label
        block_widget.wht_label = wht_label
        block_widget.min_label = min_label
        block_widget.btn_offset = btn_offset
        block_widget.dropd_profile = dropd_profile

        # Create a Matplotlib figure and canvas for the graph
        plt.style.use('dark_background')

        fig, ax = plt.subplots()
        plt.subplots_adjust(left=-0.01, right=1, top=1.01, bottom=0)
        ax.set_facecolor('#3a3a3a')
        ax.set_xticks([])  # Hide x-axis values
        ax.set_frame_on(True)
        # ax.set_ylabel('Diameter (mm)')  # Show y-axis label
        
        self.line2, = ax.plot([], [], '#00ff50', linewidth=0.5)
        self.line3, = ax.plot([], [], '#fffb00', linewidth=0.5)
        self.line1, = ax.plot([], [], '#ff5000', linewidth=1.5)

        self.canvas = FigureCanvas(fig)
        self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored)
        center_layout.addWidget(self.canvas)

        return block_widget
    
    def on_profile_changed(self, index):
        # Get the selected ID
        selected_id = self.sender().itemData(index)

        if selected_id in self.profile_data:
            start_value = self.profile_data[selected_id]['start']
            width_value = self.profile_data[selected_id]['width']
            
            self.set_limits(start_value, width_value)

    def update_profiles(self):
        url = f"http://462filament/api.php?data=profiles"
        try:
            response = requests.get(url)
            if response.status_code == 200:
                profiles = response.json()
                if profiles:
                    self.block.dropd_profile.clear()
                    self.block.dropd_profile.addItem("Select a profile...")
                    self.block.dropd_profile.model().item(0).setEnabled(False)
                    for profile in profiles:
                        profile_id = profile["id"]
                        profile_name = profile["show_name"]
                        start_value = int(profile["start"])
                        width_value = int(profile["width"])
                        self.block.dropd_profile.addItem(profile_name, profile_id)
                        self.profile_data[profile_id] = {'start': start_value, 'width': width_value}
        except requests.RequestException as e:
            print(f"Error making request to API: {e}")
        return None

    def query_api(self):
        try:
            url = f"http://462filament/api.php?data=bench&benchid={self.bench_id}"
            response = requests.get(url)
            response.raise_for_status()  # Raise an exception for HTTP errors
            api_job = response.json()  # Parse the JSON response
            
            self.api_job = api_job

            if self.api_job is not None:
                # print(f"id{self.bench_id}:\tgot job {api_job['spool']} from API")
                self.block.data_label.setText(
                    f"Job/Spool: {api_job['spool']}<hr>"
                    f"Fabricant: {api_job['vendor']}<br>"
                    f"Matière: {api_job['material']}<br>"
                    f"Lot: {api_job['batch']}<br>"
                    f"Identifiant: {api_job['description']}<hr>"
                    f"ρ = {api_job['density']}<br>"
                )
                self.density = float(api_job['density'])
                self.can_start = True
            else:
                # print(f"id{self.bench_id}:\tno job from API")
                self.block.data_label.setText(
                    f"API responded with no job"
                )
                self.can_start = False
        except requests.RequestException as e:
            print(f"Error querying API: {e}")