Arch/services/schema_service.py

import os
import json
from datetime import datetime
import pytz
from flask import current_app
from utils.file_utils import load_json_file, save_json_file


def get_schemas_file_path():
    """Obtener ruta al archivo de esquemas."""
    storage_path = current_app.config["STORAGE_PATH"]
    return os.path.join(storage_path, "schemas", "schema.json")


def get_all_schemas():
    """Obtener todos los esquemas disponibles."""
    return load_json_file(get_schemas_file_path(), {})


def get_schema_by_id(schema_id):
    """
    Obtener un esquema por su ID.

    Args:
        schema_id (str): ID del esquema a buscar

    Returns:
        dict: Datos del esquema o None si no existe
    """
    schemas = get_all_schemas()
    return schemas.get(schema_id)


def create_schema(schema_data, user_id):
    """
    Crear un nuevo esquema.

    Args:
        schema_data (dict): Datos del esquema
        user_id (str): ID del usuario que crea el esquema

    Returns:
        tuple: (éxito, mensaje)
    """
    schemas = get_all_schemas()

    # Verificar si ya existe un esquema con ese código
    schema_id = schema_data["codigo"]
    if schema_id in schemas:
        return False, f"Ya existe un esquema con el código {schema_id}."

    # Añadir metadatos
    schema_data["fecha_creacion"] = datetime.now(pytz.UTC).isoformat()
    schema_data["creado_por"] = user_id

    # Guardar esquema
    schemas[schema_id] = schema_data
    save_json_file(get_schemas_file_path(), schemas)

    return True, f"Esquema '{schema_data['descripcion']}' creado correctamente."


def update_schema(schema_id, schema_data):
    """
    Actualizar un esquema existente.

    Args:
        schema_id (str): ID del esquema a actualizar
        schema_data (dict): Nuevos datos del esquema

    Returns:
        tuple: (éxito, mensaje)
    """
    schemas = get_all_schemas()

    # Verificar si existe el esquema
    if schema_id not in schemas:
        return False, f"No existe un esquema con el código {schema_id}."

    # Preservar metadatos originales
    schema_data["fecha_creacion"] = schemas[schema_id].get("fecha_creacion")
    schema_data["creado_por"] = schemas[schema_id].get("creado_por")
    schema_data["ultima_modificacion"] = datetime.now(pytz.UTC).isoformat()

    # Actualizar esquema
    schemas[schema_id] = schema_data
    save_json_file(get_schemas_file_path(), schemas)

    return True, f"Esquema '{schema_data['descripcion']}' actualizado correctamente."


def delete_schema(schema_id):
    """
    Eliminar un esquema.

    Args:
        schema_id (str): ID del esquema a eliminar

    Returns:
        tuple: (éxito, mensaje)
    """
    schemas = get_all_schemas()

    # Verificar si existe el esquema
    if schema_id not in schemas:
        return False, f"No existe un esquema con el código {schema_id}."

    # Verificar si el esquema está en uso
    # [Implementar verificación si el esquema está asociado a proyectos]

    # Eliminar esquema
    schema_desc = schemas[schema_id].get("descripcion", schema_id)
    del schemas[schema_id]
    save_json_file(get_schemas_file_path(), schemas)

    return True, f"Esquema '{schema_desc}' eliminado correctamente."


def initialize_default_schemas():
    """Inicializar esquemas predeterminados si no existen."""
    schemas = get_all_schemas()

    # Si ya hay esquemas, no hacer nada
    if schemas:
        return

    # Esquema predeterminado para proyecto estándar
    default_schema = {
        "ESQ001": {
            "codigo": "ESQ001",
            "descripcion": "Proyecto estándar",
            "fecha_creacion": datetime.now(pytz.UTC).isoformat(),
            "creado_por": "admin",
            "documentos": [
                {
                    "tipo": "pdf",
                    "nombre": "Manual de Usuario",
                    "nivel_ver": 0,
                    "nivel_editar": 5000,
                },
                {
                    "tipo": "dwg",
                    "nombre": "Planos Técnicos",
                    "nivel_ver": 0,
                    "nivel_editar": 5000,
                },
                {
                    "tipo": "zip",
                    "nombre": "Archivos Fuente",
                    "nivel_ver": 1000,
                    "nivel_editar": 5000,
                },
            ],
        }
    }

    save_json_file(get_schemas_file_path(), default_schema)
    current_app.logger.info("Esquemas predeterminados inicializados.")


def get_schema_document_types(schema_id):
    """
    Obtener los tipos de documentos definidos en un esquema.

    Args:
        schema_id (str): ID del esquema

    Returns:
        list: Lista de tipos de documentos en el esquema, o lista vacía si no existe
    """
    schema = get_schema_by_id(schema_id)

    if not schema or "documentos" not in schema:
        return []

    return schema["documentos"]