# Optimized Python Code
# Archivo: DMbreakers.py
# Ruta: src\App\Ventas_Module\VentasEUA\DataMaster\DMbreakers.py
# Lenguaje: Python con Flask

from flask import Flask, render_template, send_file, abort, url_for, jsonify, request,session
import os
from dotenv import load_dotenv
import ftplib
from werkzeug.utils import secure_filename
import tempfile
from App.Security_Module.UserPassword import user_has_access
from App.Subir_Archivo import subir_archivo_ftp_desde_request,view_pdf_file,verificar_actualizar_archivos
from Consultas_SQL.Ventas.VentasEUA.DataMaster.DMbreakersSQL import (
    get_breakers, insert_breaker,update_breaker,delete_breaker,item_exists,searchitems,update_breaker_TechnicalSheet
)
"""
from Consultas_SQL.Ventas.VentasEUA.DataMaster.DMBreakersOptimizadoSQL import (
    get_breakers, insert_breaker,update_breaker,delete_breaker,item_exists,searchitems,update_breaker_TechnicalSheet
)
"""
import requests
import os
# Cargar las variables de entorno desde el archivo .env
load_dotenv()
# /////////////////////////////////
#   Variables Generales
# ////////////////////////////////
# ruta_pdf = "/var/www/html/src/static/pdf/Ventas/EUA/DMITEMS/BREAKER_CATALOG"
ruta_pdf = "/domains/sycelephant.com/public_html/file/Ventas/EUA/DMITEMS/BREAKER_CATALOG"
carpeta = "/Ventas/EUA/DMITEMS/BREAKER_CATALOG/"
# /////////////////////////////////
#   Funciones Genericas
# ////////////////////////////////

# /////////////////////////////////
#   Varifica items Repetidos
# ////////////////////////////////
def existen_items(item):
    result = item_exists(item)
    if result:  # Verifica si result no es None (puede ser None si la consulta no encuentra nada)
        count = int(result[0]) # Accede al primer elemento de la tupla (índice 0) y lo convierte a entero.
    else:
        count = 0
    return count

# /////////////////////////////////
#   Funciones dedicadas
# ////////////////////////////////

def register_dmbreakers_routes(app):
    # /////////////////////////////////
    #   Consultar Breakers
    # ////////////////////////////////
    @app.route("/ventas/data_master/brakers/listbreakers", methods=["GET"])
    def list_breakers():
        """
        user_id = session.get('user_id')
        if not user_has_access(user_id, "Ventas","read"):
            message = "No tiene permisos para visualizar este archivo"
            return render_template("Security/AccessDened.html",message)
        """
        """Retorna la lista de departamentos."""
        try:
            departament = get_breakers()
            return jsonify(departament), 200
        except Exception as e:
            return jsonify({"error": str(e)}), 500
    # Función para verificar si un item ya existe en la base de datos
    
    @app.route("/ventas/pdf_viewer/view/<path:filename_or_url>")
    def ver_pdf(filename_or_url):
        """Endpoint para visualizar un archivo PDF específico."""
        return view_pdf_file(filename_or_url)
    # /////////////////////////////////
    #   Guardar Breakers
    # ////////////////////////////////
    @app.route("/ventas/data_master/brakers/addbreaker", methods=["POST"])
    def add_breaker():
        user_id = session.get('user_id')
        
        try:
            item = request.form.get("item")
            description = request.form.get("description")
            price = request.form.get("price")
            type = request.form.get("type")
            technicalSheet = request.files.get("TechnicalSheet")
            
            if not all([item, description, price, type]): 
                return jsonify({"error": "Todos los campos son obligatorios."}), 400
            
            # Verificar si el item ya existe
            if existen_items(item) == 1:
                return jsonify({"error": "El item ya existe en el catálogo."}), 400
            
            filename = None
            if technicalSheet:
                # Definir la ruta donde guardar el PDF
                
                resultado = subir_archivo_ftp_desde_request(technicalSheet, item, ruta_pdf,carpeta)
                
                if resultado["exito"]:
                    filename = resultado["url_web"]
                else:
                    return jsonify({"error": resultado["mensaje"]}), 400
            
            # Database Insert
            result = insert_breaker(item, description, price, type, filename)
                 # Database Insert - usando enfoque de diccionario
            """
            data_dict = {
                "Item_breaker": item,
                "description": description,
                "price": price,
                "type": type,
                "TechnicalSheet": filename
            }
            result = insert_breaker(data_dict)
            """
            return jsonify({"message": "Breaker agregado exitosamente."}), 201
        
        except Exception as e:
            return jsonify({"error": str(e)}), 500
    # /////////////////////////////////
    #   Actualizar inputs de  Breakers
    # ////////////////////////////////
    @app.route("/ventas/data_master/brakers/updatebreaker", methods=["POST"])
    def update_breaker_route():
        
        """Actualiza un breaker en la base de datos."""
        try:
            data = request.get_json()
            item = data.get("item")
            description = data.get("description")
            price = data.get("price")
            type = data.get("type")

            if not all([item, description, price, type]):
                return jsonify({"error": "Todos los campos son obligatorios."}), 400

            update_breaker(item, description, price, type)
            """
            data_dict = {
            "Item_breaker": item,
            "description": description,
            "price": price,
            "type": type
            }
        
            # Llamar a la función de actualización con el diccionario
            update_breaker(data_dict)
            """
            return jsonify({"message": "Breaker actualizado exitosamente."}), 200
        except Exception as e:
            return jsonify({"error": str(e)}), 500
        
    # /////////////////////////////////
    #   Eliminar Breakers
    # ////////////////////////////////
    @app.route("/ventas/data_master/brakers/deletebreaker", methods=["POST"])
    def delete_breaker_route():
        """Elimina un breaker de la base de datos."""
        try:
            data = request.get_json()
            item = data.get("item")
            if not item:
                return jsonify({"error": "El campo Item es obligatorio."}), 400
            delete_breaker(item)
            return jsonify({"message": "Breaker eliminado exitosamente."}), 200
        except Exception as e:
            return jsonify({"error": str(e)}), 500
            
    # /////////////////////////////////
    #   Revisar la tabla CZE_BreakersCatalog y verificar si estan en archivos de fichas tecnicas  
    # ////////////////////////////////
        
    @app.route("/ventas/data_master/brakers/actualizarbreaker", methods=["GET"])
    def updated_breaker_route():
        #Actualiza todas las Fichas técnicas verificando su existencia en el servidor.
        
        try:
            # Configuramos la ruta al módulo y el nombre de la función
            module_path = "Consultas_SQL.Ventas.VentasEUA.DataMaster.DMbreakersSQL"  # Corregido el nombre del módulo
            function_name = "searchitems"
            
            # Llamamos a verificar_actualizar_archivos con la configuración dinámica
            resultado = verificar_actualizar_archivos(
                tabla="CZE_BreakersCatalog",
                campo_id="Item_breaker",  # Asegúrate de que esto coincida con la clave en el diccionario
                campo_url="TechnicalSheet",
                update_function=update_breaker_TechnicalSheet,
                ruta_remota=ruta_pdf,
                search_function_name=function_name,  # Pasamos el nombre de la función
                module_path=module_path,             # Pasamos la ruta al módulo
                base_url="https://file.sycelephant.com",
                carpeta = carpeta
            )
            if resultado["exito"]:
                return jsonify({"message": resultado["mensaje"]}), 200
            else:
                print(f"Error en actualización: {resultado['mensaje']}")
                return jsonify({"error": resultado["mensaje"]}), 500
                    
        except Exception as e:
            import traceback
            print(f"Error en la actualización: {str(e)}")
            print(traceback.format_exc())
            return jsonify({"error": str(e)}), 500