src/services/json_generator.py

import datetime
import json
import tempfile
import uuid
from assets.utils.validation import validate_boamps_schema
from src.services.report_builder import ReportBuilder
import os


def process_component_list(fields_dict):
    """
    Fonction générique pour traiter une liste de composants à partir d'un dictionnaire de champs.

    Args:
        fields_dict (dict): Dictionnaire où les clés sont les noms des champs
                           et les valeurs sont des listes de composants Gradio ou des objets gr.State.

    Returns:
        list: Liste de dictionnaires représentant les composants.
    """
    component_list = []

    # Extract values from different input types
    processed_fields = {}
    for field_name, field_values in fields_dict.items():
        if hasattr(field_values, 'value'):  # It's a gr.State object
            processed_fields[field_name] = field_values.value if field_values.value else [
            ]
        elif isinstance(field_values, list) and len(field_values) > 0:
            # It's a list of Gradio components or values
            values = []
            for item in field_values:
                if hasattr(item, '__class__') and 'gradio' in str(item.__class__):
                    # It's a Gradio component, the value was passed as input to this function
                    # We need to handle this in the calling function by passing the values directly
                    values.append(item if item is not None else "")
                else:
                    # It's already a value
                    values.append(item if item is not None else "")
            processed_fields[field_name] = values
        else:
            processed_fields[field_name] = field_values if field_values else []

    # Trouver le nombre maximum d'éléments parmi tous les champs
    max_items = 0
    for field_values in processed_fields.values():
        if field_values:
            max_items = max(max_items, len(field_values))

    # Créer les composants
    for i in range(max_items):
        component = {}

        for field_name, field_values in processed_fields.items():
            if i < len(field_values):
                value = field_values[i]
                # Only add the field if it has a meaningful value (not empty, not just whitespace)
                if value is not None and str(value).strip() != "":
                    component[field_name] = value

        # Add component if it has any field (as requested by user)
        if component:
            component_list.append(component)

    return component_list


def generate_json(
    # Header
    licensing, formatVersion, formatVersionSpecificationUri, reportId,
    reportDatetime, reportStatus, publisher_name, publisher_division,
    publisher_projectName, publisher_confidentialityLevel, publisher_publicKey,
    # Task
    taskFamily, taskStage, nbRequest,
    trainingType, algorithmType, algorithmName, algorithmUri, foundationModelName, foundationModelUri, parametersNumber, framework,  frameworkVersion, classPath, layersNumber, epochsNumber, optimizer, quantization,
    dataUsage, dataType, dataFormat, dataSize, dataQuantity, shape, source, sourceUri,  owner,
    measuredAccuracy, estimatedAccuracy, taskDescription,
    # Measures
    measurementMethod, manufacturer, version, cpuTrackingMode, gpuTrackingMode,
    averageUtilizationCpu, averageUtilizationGpu, powerCalibrationMeasurement,
    durationCalibrationMeasurement, powerConsumption,
    measurementDuration, measurementDateTime,
    # System
    osystem, distribution, distributionVersion,
    # Software
    language, version_software,
    # Infrastructure
    infraType, cloudProvider, cloudInstance, cloudService, componentName, componentType,
    nbComponent, memorySize, manufacturer_infra, family,
    series, share,
    # Environment
    country, latitude, longitude, location,
    powerSupplierType, powerSource, powerSourceCarbonIntensity,
    # Quality
    quality
):
    """Generate JSON data from form inputs using optimized ReportBuilder."""

    try:
        # Use ReportBuilder for cleaner, more maintainable code
        builder = ReportBuilder()

        # Create a uuid & a report datetime if not filled by the user
        if not reportId:
            reportId = str(uuid.uuid4())
        if not reportDatetime:
            reportDatetime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        # Build header section
        header_data = {
            "licensing": licensing,
            "formatVersion": formatVersion,
            "formatVersionSpecificationUri": formatVersionSpecificationUri,
            "reportId": reportId,
            "reportDatetime": reportDatetime,
            "reportStatus": reportStatus,
            "publisher_name": publisher_name,
            "publisher_division": publisher_division,
            "publisher_projectName": publisher_projectName,
            "publisher_confidentialityLevel": publisher_confidentialityLevel,
            "publisher_publicKey": publisher_publicKey
        }
        builder.add_header(header_data)

        # Build task section
        task_data = {
            "taskStage": taskStage,
            "taskFamily": taskFamily,
            "nbRequest": nbRequest,
            "measuredAccuracy": measuredAccuracy,
            "estimatedAccuracy": estimatedAccuracy,
            "taskDescription": taskDescription,
            "algorithms": {
                "trainingType": trainingType,
                "algorithmType": algorithmType,
                "algorithmName": algorithmName,
                "algorithmUri": algorithmUri,
                "foundationModelName": foundationModelName,
                "foundationModelUri": foundationModelUri,
                "parametersNumber": parametersNumber,
                "framework": framework,
                "frameworkVersion": frameworkVersion,
                "classPath": classPath,
                "layersNumber": layersNumber,
                "epochsNumber": epochsNumber,
                "optimizer": optimizer,
                "quantization": quantization
            },
            "dataset": {
                "dataUsage": dataUsage,
                "dataType": dataType,
                "dataFormat": dataFormat,
                "dataSize": dataSize,
                "dataQuantity": dataQuantity,
                "shape": shape,
                "source": source,
                "sourceUri": sourceUri,
                "owner": owner
            }
        }
        builder.add_task(task_data)

        # Build measures section
        measures_data = {
            "measurementMethod": measurementMethod,
            "manufacturer": manufacturer,
            "version": version,
            "cpuTrackingMode": cpuTrackingMode,
            "gpuTrackingMode": gpuTrackingMode,
            "averageUtilizationCpu": averageUtilizationCpu,
            "averageUtilizationGpu": averageUtilizationGpu,
            "powerCalibrationMeasurement": powerCalibrationMeasurement,
            "durationCalibrationMeasurement": durationCalibrationMeasurement,
            "powerConsumption": powerConsumption,
            "measurementDuration": measurementDuration,
            "measurementDateTime": measurementDateTime
        }
        builder.add_measures(measures_data)

        # Build system section
        system_data = {
            "osystem": osystem,
            "distribution": distribution,
            "distributionVersion": distributionVersion
        }
        builder.add_system(system_data)

        # Build software section
        software_data = {
            "language": language,
            "version_software": version_software
        }
        builder.add_software(software_data)

        # Build infrastructure section
        infrastructure_data = {
            "infraType": infraType,
            "cloudProvider": cloudProvider,
            "cloudInstance": cloudInstance,
            "cloudService": cloudService,
            "components": {
                "componentName": componentName,
                "componentType": componentType,
                "nbComponent": nbComponent,
                "memorySize": memorySize,
                "manufacturer": manufacturer_infra,
                "family": family,
                "series": series,
                "share": share
            }
        }
        builder.add_infrastructure(infrastructure_data)

        # Build environment section
        environment_data = {
            "country": country,
            "latitude": latitude,
            "longitude": longitude,
            "location": location,
            "powerSupplierType": powerSupplierType,
            "powerSource": powerSource,
            "powerSourceCarbonIntensity": powerSourceCarbonIntensity
        }
        builder.add_environment(environment_data)

        # Add quality
        builder.add_quality(quality)

        # Build the final report
        report = builder.build()

        # Validate that the schema follows the BoAmps format
        is_valid, message = validate_boamps_schema(report)
        if not is_valid:
            return message, None, ""

        # Create and save the JSON file
        filename = f"report_{taskStage}_{taskFamily}_{infraType}_{reportId}.json"
        filename = filename.replace(" ", "-")

        # Create the JSON string
        json_str = json.dumps(report, indent=4, ensure_ascii=False)

        # Write JSON to a temporary file with the desired filename
        temp_dir = tempfile.gettempdir()
        temp_path = os.path.join(temp_dir, filename)
        with open(temp_path, "w", encoding="utf-8") as tmp:
            tmp.write(json_str)

        return message, temp_path, json_str

    except Exception as e:
        return f"Error generating JSON: {str(e)}", None, ""