import sempy_labs as labs
import sempy.fabric as fabric
import pandas as pd
from pyspark.sql.types import *
from pyspark.sql.functions import col

def get_file_details_recursive(folder_path):
    file_details_list = []
    try:
        items = notebookutils.fs.ls(folder_path)

        for item in items:
            item_path_full = item.path
            if not item_path_full.startswith("abfss://"):
                 if folder_path.endswith('/'):
                     item_path_full = folder_path + item.name
                 else:
                     item_path_full = folder_path + '/' + item.name

            if not item.isDir:
                file_details_list.append({'path': item_path_full, 'size_bytes': item.size})
            else:
                current_folder_normalized = folder_path.rstrip('/')
                item_folder_normalized = item_path_full.rstrip('/')

                if item_folder_normalized != current_folder_normalized:
                    sub_dir_files = get_file_details_recursive(item_path_full)
                    if sub_dir_files:
                        file_details_list.extend(sub_dir_files)

    except Exception as e:
        print(f"WARN: Error al escanear la carpeta '{folder_path}'. Omitiendo esta ruta.")
        return []

    return file_details_list

all_files_data = []
processed_workspaces = 0
total_workspaces = 0

print("Iniciando escaneo de workspaces...")

try:
    workspaces_pd = fabric.list_workspaces()
    total_workspaces = len(workspaces_pd)
    print(f"Se encontraron {total_workspaces} áreas de trabajo accesibles.")

    for ws_index, ws_row in workspaces_pd.iterrows():
        workspace_name = ws_row['Name']
        workspace_id = ws_row['Id']
        processed_workspaces += 1
        print(f"\n[{processed_workspaces}/{total_workspaces}] 📂 Procesando Workspace: '{workspace_name}' (ID: {workspace_id})")

        try:
            items_pd = fabric.list_items(workspace=workspace_id)
            print(f"  -> Se encontraron {len(items_pd)} artefactos escaneables en '{workspace_name}'.")

            for item_index, item_row in items_pd.iterrows():
                artifact_type = item_row['Type']
                artifact_name = item_row['Display Name']
                artifact_id = item_row['Id']

                artifact_root_path = f"abfss://{workspace_id}@onelake.dfs.fabric.microsoft.com/{artifact_id}"

                print(f"    -> 🔍 Escaneando artefacto: '{artifact_name}' (Tipo: {artifact_type}, ID: {artifact_id})")

                files_in_artifact = []
                special_size_bytes = -1

                try:
                    if artifact_type == 'SemanticModel':
                        print(f"      -> Intentando obtener tamaño para Semantic Model '{artifact_name}'...")
                        size = labs.get_semantic_model_size(artifact_id, workspace_id)
                        if size is not None:
                            special_size_bytes = int(size)
                        
                        print(f"      => Tamaño obtenido de sempy_labs: {special_size_bytes} bytes.")

                        all_files_data.append({
                                "WorkspaceID": workspace_id, 
                                "WorkspaceName": workspace_name,
                                "ArtifactType": artifact_type, 
                                "ArtifactName": artifact_name, 
                                "ArtifactID": artifact_id,
                                "ScannedRootPath": artifact_root_path,
                                "FilePath": f"{artifact_root_path}",
                                "SizeBytes": special_size_bytes,
                                "SizeMB": float(special_size_bytes / (1024 * 1024)) if special_size_bytes > 0 else 0.0
                        })
                    else:
                        files_in_artifact = get_file_details_recursive(artifact_root_path + "/")

                    if files_in_artifact and artifact_type != 'SemanticModel':
                        print(f"      => Se encontraron {len(files_in_artifact)} archivos para '{artifact_name}'.")
                        for file_detail in files_in_artifact:
                            file_size_bytes = int(file_detail['size_bytes'])
                            file_size_mb = float(file_size_bytes / (1024 * 1024)) if file_size_bytes > 0 else 0.0

                            all_files_data.append({
                                "WorkspaceID": workspace_id,
                                "WorkspaceName": workspace_name,
                                "ArtifactType": artifact_type,
                                "ArtifactName": artifact_name,
                                "ArtifactID": artifact_id,
                                "ScannedRootPath": artifact_root_path,
                                "FilePath": file_detail['path'],
                                "SizeBytes": file_size_bytes,
                                "SizeMB": file_size_mb
                            })
                    else:
                        print(f"      => No se encontraron archivos accesibles vía ABFSS para '{artifact_name}' o está vacío.")

                except Exception as scan_error:
                    print(f"      => ERROR escaneando el artefacto '{artifact_name}' en '{artifact_root_path}'.")
                    all_files_data.append({
                                "WorkspaceID": workspace_id,
                                "WorkspaceName": workspace_name,
                                "ArtifactType": artifact_type,
                                "ArtifactName": artifact_name,
                                "ArtifactID": artifact_id,
                                "ScannedRootPath": artifact_root_path,
                                "FilePath": "ERROR_SCANNING_ARTIFACT",
                                "SizeBytes": -1,
                                "SizeMB": -1.0
                            })

        except Exception as item_error:
            print(f"  -> ERROR al listar artefactos para el workspace '{workspace_name}': {item_error}")
            continue

except Exception as ws_error:
    print(f"FATAL: Error crítico al obtener la lista de workspaces: {ws_error}")

print(f"\n📊 Escaneo completado. Se recopilaron {len(all_files_data)} registros de archivos.")