import csv
import locale
import os
import sys
import weakref
from glob import glob

from lib.db import Recipes, Users, db
from PyQt5.QtCore import QTimer, pyqtSignal
from PyQt5.QtGui import QKeySequence
from PyQt5.QtWidgets import QFileDialog, QMessageBox, QShortcut
import shutil

from lib.helpers.recipe_manager import export_recipes, import_recipes
from ui.crud import Crud, Json_External_Dialog_Editor_Cell_Widget
from ui.helpers import replace_widget
from ui.recipe_spec_and_step_editor import Recipe_Spec_And_Step_Editor
from ui.widget import Widget

from datetime import datetime

class Noner:
    def __getitem__(self, key):
        return None


noner = Noner()


class Recipe_Selection(Widget):
    ok = pyqtSignal(Recipes)

    def __init__(self, config, unsupported_steps=None):
        global noner
        super().__init__()
        self.config = config
        self.second_leak_test_enabled = self.config["hardware_config"]["second_leak_test"] == "present"
        self.defaults = self.config.get("recipes_defaults", noner)
        self.unsupported_steps = unsupported_steps
        session = Users.get_session()
        if session.is_admin:
            readonly = False
            crud_aliases = {
                "name": "Ricetta",
                "client": "Cliente",
                "part_number": "N° disegno",
                "spec": "Specifica",
                "description": "Descrizione",
            }
            filters = None
        else:
            readonly = True
            crud_aliases = {
                "name": "Ricetta",
                "client": "Cliente",
                "part_number": "N° disegno",
                "spec": "Specifica",
                "description": "Descrizione",
            }
            filters = {"archived": False}
        step_defaults = self.read_steps(self.config.get("recipes_defaults", noner), noner)
        custom_label_folder = f"config/label_templates/{str(self.config.machine_id)}/"
        standard_label_folder = f"config/label_templates/"
        if os.path.exists(custom_label_folder):
            label_folder = custom_label_folder
        else:
            label_folder = standard_label_folder

        step_defaults.update({
            "vision": {
                # "recipe": sorted(glob("*.ini", root_dir="./config/vision/recipes/")), # only in python3.10
                "recipe": sorted(map(os.path.basename, glob("./config/vision/recipes/*.ini"))),
            },
            "print": {
                # "template": sorted(glob("*.prn", root_dir="./config/label_templates/")), # only in python3.10
                "template": sorted(map(os.path.basename, glob(f"{label_folder}*.prn"))),
            },
        }),
        self.crud = Crud(
            "recipes",
            display_name="SELEZIONE RICETTA",
            readonly=readonly,
            select=list(crud_aliases.keys()),
            filters=filters,
            fields_aliases=crud_aliases,
            autocomplete={
                "name": self.config.get("recipes_defaults", noner)["codice_ricetta"],
                "client": self.config.get("recipes_defaults", noner)["cliente"],
                "part_number": self.config.get("recipes_defaults", noner)["part_number"],
                "spec": {
                    "count": len(self.config.get("recipes_defaults", noner)["dimensione_lotto_abilitata"]) and "count" not in self.unsupported_steps,
                    "connector": len(self.config.get("recipes_defaults", noner)["verifica_connettore_abilitata"]) and "connector" not in self.unsupported_steps,
                    "barcodes": len(
                        self.config.get("recipes_defaults", noner)["verifica_codice_a_barre_abilitata"]) and "barcodes" not in self.unsupported_steps,
                    "resistance": len(
                        self.config.get("recipes_defaults", noner)["verifica_resistenza_connettore_abilitata"]) and "resistance" not in self.unsupported_steps,
                    "screws": len(self.config.get("recipes_defaults", noner)["avvitatura_abilitata"]) and "screws" not in self.unsupported_steps,
                    "instruction": len(self.config.get("recipes_defaults", noner)["istruzione_abilitata"]) and "instruction" not in self.unsupported_steps,
                    "instruction_extra": len(self.config.get("recipes_defaults", noner)["istruzione_abilitata_extra"]) and "instruction_extra" not in self.unsupported_steps,
                    "pipe_cutter": len(self.config.get("recipes_defaults", noner)["tagliatubi_abilitata"]) and "pipe_cutter" not in self.unsupported_steps,
                    "vision": len(self.config.get("recipes_defaults", noner)["test_visione_abilitato"]) and "vision" not in self.unsupported_steps,
                    "leak_1": len(self.config.get("recipes_defaults", noner)["prova_tenuta_abilitata"]) and "leak_1" not in self.unsupported_steps,
                    "leak_2": len(self.config.get("recipes_defaults", noner)["prova_tenuta_abilitata_2"]) and "leak_2" not in self.unsupported_steps,
                    "print": len(self.config.get("recipes_defaults", noner)["stampa_etichetta_abilitata"]) and "print" not in self.unsupported_steps,
                    "step_editors": step_defaults,
                },
                "description": self.config.get("recipes_defaults", noner)["descrizione"],
                "archived": False,
            },
            sort={"name": True},
            widget_classes={"spec": lambda *args, **kwargs: Json_External_Dialog_Editor_Cell_Widget(
                Recipe_Spec_And_Step_Editor,
                *args,
                **kwargs,
                unsupported_steps=self.unsupported_steps
            ), },
            pagination=25,
        )
        replace_widget(self, "crud_w", self.crud)
        self.crud_modified = None
        self.selected = None
        self.select_b.setEnabled(False)
        self.select_b.clicked.connect(self.select)
        QShortcut(QKeySequence("Return"), self).activated.connect(self.select_b.click)
        QShortcut(QKeySequence("Enter"), self).activated.connect(self.select_b.click)
        self.crud.modified.connect(self.check_modified)
        self.crud.selected.connect(self.check_selected)
        self.crud.emit()
        self.crud.db_tw.setColumnWidth(0, 200)
        self.crud.db_tw.setColumnWidth(1, 200)
        self.crud.db_tw.setColumnWidth(2, 200)
        self.crud.db_tw.setColumnWidth(3, 200)
        self.crud.db_tw.setColumnWidth(4, 200)
        self.crud.db_tw.setColumnWidth(5, 400)
        if session.is_admin:
            self.import_b.clicked.connect(lambda checked, selfi=weakref.ref(self): selfi().import_recipes())
            self.export_b.clicked.connect(lambda checked, selfi=weakref.ref(self): selfi().export_recipes())
            self.delete_all_b.clicked.connect(lambda checked, selfi=weakref.ref(self): selfi().delete_recipes())
        else:
            self.import_b.setVisible(False)
            self.export_b.setVisible(False)
            self.delete_all_b.setVisible(False)

        # TESTING
        if self.config.auto_select is not None:
            recipe = self.config.auto_select
            cn = self.crud.select_index["name"]
            self.crud.db_tw.clearSelection()
            for rn in range(1, self.crud.db_tw.rowCount()):
                if self.crud.db_tw.cellWidget(rn, cn).text() == recipe:
                    selection = self.crud.db_tw.model().index(rn, cn)
                    self.crud.db_tw.setCurrentIndex(selection)
                    break
            self.test_timer = QTimer()
            self.test_timer.setSingleShot(True)
            self.test_timer.timeout.connect(self.select_b.clicked.emit)
            self.test_timer.start(500)
        # /TESTING

    def check_modified(self, modified):
        self.crud_modified = modified
        self.check(self.crud_modified, self.selected)

    def check_selected(self, selected=None):
        if selected is not None and len(selected) == 1:
            selected = selected[0] - 1  # - 1 because rn starts from 1 (filters line)
            if selected >= 0 and selected < len(self.crud.data_index):
                selected = self.crud.data_index[selected]
                if selected is not None:
                    self.selected = selected
                else:
                    self.selected = None
        else:
            self.selected = None
        self.check(self.crud_modified, self.selected)

    def check(self, modified, selected):
        self.select_b.setEnabled(modified is False and selected is not None)

    def select(self):
        if self.selected is not None:
            self.ok.emit(self.crud.db.table_model.get_by_id(self.selected))

    def get_def(self, dict, key):
        val = dict.get(key, self.defaults[key])
        return val if val != "" else self.defaults[key]

    # READ RECIPE STEPS FROM CSV ROW
    def read_steps(self, row, defaults=None):
        if defaults is None:
            global noner
            defaults = self.config.get("recipes_defaults", noner)
        barcode_serial_field = self.config.get("recipe", {}).get("barcode_serial_field", "codice_a_barre").strip()
        warning_image_field = self.config.get("recipe", {}).get("warning_image_field", "warning_img").strip()
        decsep = locale.localeconv()["decimal_point"]
        rcsv = row.get("r nominale", defaults["r nominale"]).replace(" ", "").replace(",", decsep).replace("Ω", "").replace("?", "")
        if rcsv == "":
            rcsv = "999"
        print_template_field = self.config.get("recipe", {}).get("label_template_field", "modello_etichetta").strip()
        return {
            "count": {
                "amount": row.get("dimensione_lotto", defaults["dimensione_lotto"]),
                "warning_img": row.get(warning_image_field, defaults["warning_img"]),
                "require_discard_piece": row.get("richiedi_inserimento_scarto", defaults["richiedi_inserimento_scarto"])
            },
            "connector": {
                "connector": row.get("connettore", defaults["connettore"]),
            },
            "barcodes": {
                "serial": row.get(barcode_serial_field, defaults["codice_a_barre"]),
                "n_pieces": row.get("n_componenti") or defaults["n_componenti"],
                "barcode_input_2": row.get("barcode_input_2", "-"),
                "barcode_input_3": row.get("barcode_input_3", "-"),
                "barcode_input_4": row.get("barcode_input_4", "-"),
                "barcode_input_5": row.get("barcode_input_5", "-"),
            },
            "resistance": {
                "scale": locale.atof(row.get("scala_resistenza", defaults["scala_resistenza"])),
                "expected": locale.atof(rcsv),
                "tolerance_pos": locale.atof(self.get_def(row, "tolleranza_resistenza_pos")),
                "tolerance_neg": locale.atof(self.get_def(row, "tolleranza_resistenza_neg")),
            },
            "screws": {
                "quantity": row.get("viti", defaults["viti"])
            },
            "instruction": {},
            "pipe_cutter": {
                "length": row.get("lunghezza_corrugato", defaults["lunghezza_corrugato"]),
                "diameter": row.get("diametro", defaults["diametro"]),
            },
            "leak_1": {
                "pre_filling_time": int(float(row.get("tempo_pre_riempimento", defaults["tempo_pre_riempimento"]))),
                "pre_filling_pressure": int(float(row.get("pressione_pre_riempimento", defaults["pressione_pre_riempimento"]))),
                "filling_time": int(float(row.get("tempo_riempimento", defaults["tempo_riempimento"]))),
                "settling_time": int(float(self.get_def(row, "tempo_assestamento"))),
                "settling_pressure_min_percent": int(float(
                    row.get("percentuale_minima_pressione_assestamento", defaults["percentuale_minima_pressione_assestamento"]))),
                "settling_pressure_max_percent": int(float(
                    row.get("percentuale_massima_pressione_assestamento", defaults["percentuale_massima_pressione_assestamento"]))),
                "test_time": int(float(row.get("tempo_di_test", defaults["tempo_di_test"]))),
                "test_pressure_qneg": int(float(row.get("pressione_di_test_delta_minimo", defaults["pressione_di_test_delta_minimo"]))),
                "test_pressure": int(float(row.get("pressione_di_test", defaults["pressione_di_test"]))),
                "test_pressure_qpos": int(float(row.get("pressione_di_test_delta_massimo", defaults["pressione_di_test_delta_massimo"]))),
                "flush_time": int(float(row.get("tempo_svuotamento", defaults["tempo_svuotamento"]))),
                "flush_pressure": int(float(row.get("pressione_svuotamento", defaults["pressione_svuotamento"]))),
                "chan_sel": int(float(row.get("canale_di_prova", defaults["canale_di_prova"]))),
                "ext_flush_time": int(float(row.get("tempo_svuotamento_esterno", defaults["tempo_svuotamento_esterno"]))),
                "ext_blow_time": int(float(row.get("tempo_soffiaggio_esterno", defaults["tempo_soffiaggio_esterno"]))),
                "pid_pressure_correction" : int(float(row.get("pid_pressure_correction", defaults["pid_pressure_correction"]))),
            },
            "leak_2": {
                "pre_filling_time": int(float(row.get("tempo_pre_riempimento_2", defaults["tempo_pre_riempimento_2"]))),
                "pre_filling_pressure": int(float(row.get("pressione_pre_riempimento_2", defaults["pressione_pre_riempimento_2"]))),
                "filling_time": int(float(row.get("tempo_riempimento_2", defaults["tempo_riempimento_2"]))),
                "settling_time": int(float(row.get("tempo_assestamento_2", defaults["tempo_assestamento_2"]))),
                "settling_pressure_min_percent": int(float(
                    row.get("percentuale_minima_pressione_assestamento_2", defaults["percentuale_minima_pressione_assestamento_2"]))),
                "settling_pressure_max_percent": int(float(
                    row.get("percentuale_massima_pressione_assestamento_2", defaults["percentuale_massima_pressione_assestamento_2"]))),
                "test_time": int(float(row.get("tempo_di_test_2", defaults["tempo_di_test_2"]))),
                "test_pressure_qneg": int(float(row.get("pressione_di_test_delta_minimo_2", defaults["pressione_di_test_delta_minimo_2"]))),
                "test_pressure": int(float(row.get("pressione_di_test_2", defaults["pressione_di_test_2"]))),
                "test_pressure_qpos": int(float(row.get("pressione_di_test_delta_massimo_2", defaults["pressione_di_test_delta_massimo_2"]))),
                "flush_time": int(float(row.get("tempo_svuotamento_2", defaults["tempo_svuotamento_2"]))),
                "flush_pressure": int(float(row.get("pressione_svuotamento_2", defaults["pressione_svuotamento_2"]))),
                "chan_sel": int(float(row.get("canale_di_prova_2", defaults["canale_di_prova_2"]))),
                "ext_flush_time": int(float(row.get("tempo_svuotamento_esterno_2", defaults["tempo_svuotamento_esterno"]))),
                "ext_blow_time": int(float(row.get("tempo_soffiaggio_esterno_2", defaults["tempo_soffiaggio_esterno"]))),
                "pid_pressure_correction": int(float(row.get("pid_pressure_correction_2", defaults["pid_pressure_correction_2"]))),

            },
            "vision": {
                "recipe": row.get("ricetta_visione", defaults["ricetta_visione"]),
            },
            "print": {
                "template": row.get(print_template_field, defaults["modello_etichetta"]),
                "labeltxt_1": row.get("testo_etich_1", ""),
                "labeltxt_2": row.get("testo_etich_2", ""),
                "labeltxt_3": row.get("testo_etich_3", ""),
                "labeltxt_4": row.get("testo_etich_4", ""),
                "labeltxt_5": row.get("barcode_input_finelinea", ""),
                "extra_label": row.get("etichette_supplementari", ""),

            },
        }

    # IMPORT RECIPES FROM CSV FILE TO DATABASE
    def import_recipes(self, csv_path=None, defaults=None):
        import_recipes(
            config=self.config,
            csv_path=csv_path,
            defaults=defaults,
            unsupported_steps=self.unsupported_steps,
            logger=self.log,
        )

    # EXPORT RECIPES TABLE TO CSV FILE
    def export_recipes(self, csv_path=None):
        export_recipes(
            config=self.config,
            csv_path=csv_path,
            logger=self.log,
        )

    def delete_recipes(self):
        ret = QMessageBox.warning(
            None,
            "Attenzione si sta cercando di cancellare tutte le ricette!",
            "Si è sicuri di voler eliminare tutte le ricette?\nQuesta operazione non può essere annullata!",
            buttons=QMessageBox.Ok | QMessageBox.Cancel,
            defaultButton=QMessageBox.Cancel
        )
        if ret == QMessageBox.Ok:
            Recipes.delete().execute()
            self.crud.refresh()



