from systems_definitions import get_system_name, filter_translatable_systems
from media_definitions import media_table, get_media_name
import os
import shutil
import pprint

SOURCE_FOLDER = "/home/sergio/roms/batocera_arrm_scrapped"
DEST_FOLDER = "/home/sergio/roms/es-de_from_batocera"

def list_directories(path):
    """Devuelve una lista de directorios en la ruta especificada."""
    # Lista los nombres en la ruta y verifica cuáles son directorios
    directories = [name for name in os.listdir(path) if os.path.isdir(os.path.join(path, name))]
    return directories


def list_files(path):
    """Devuelve una lista de ficheros (no directorios) en la ruta especificada, excluyendo archivos *.xml."""
    files = [
        name for name in os.listdir(path) 
        if os.path.isfile(os.path.join(path, name)) and not name.endswith(".xml")
    ]
    return files


def directory_exists(path):
    """Comprueba si un directorio existe."""
    return os.path.isdir(path)


def get_file_name_without_extension(file_path):
    """Devuelve el nombre del fichero sin su extensión."""
    file_name, _ = os.path.splitext(os.path.basename(file_path))
    return file_name


def find_file_extension(folder, base_name):
    """Busca un archivo que coincida con el nombre base y el sufijo, y devuelve solo la extensión."""
    for file in os.listdir(folder):
        if file.startswith(base_name):
            _, extension = os.path.splitext(file)  # Obtiene la extensión del archivo
            return extension  # Devuelve solo la extensión
    return None


def create_file_list():
    system_list = filter_translatable_systems(list_directories(SOURCE_FOLDER))
    file_list = []
    
    for system in system_list:
        folder = os.path.join(SOURCE_FOLDER, system)

        # Saltar sistemas sin la carpeta "downloaded_images"
        if not directory_exists(os.path.join(folder, "downloaded_images")):
            continue

        # Añade las roms de la carpeta excluyendo ficheros .xml
        roms = list_files(folder)

        # Gestiona la lista de roms
        for rom in roms:
            rom_name = get_file_name_without_extension(rom)
            element = {}

            # Configuración básica del rom
            element["name"] = rom_name
            element["rom_source"] = os.path.join(folder, rom)
            element["rom_dest"] = os.path.join(DEST_FOLDER, "ROMs", system, rom)

            # Crear el diccionario "media" con dos claves por entrada
            media_dict = {}
            for key in media_table.keys():
                base_folder = os.path.join(folder, "downloaded_images")
                base_name = f"{rom_name}-{key}"
                
                # Llamar a la función para obtener la extensión
                extension = find_file_extension(base_folder, base_name)
                
                # Verificar si se encontró la extensión
                if extension:
                    media_dict[f"{key}_source"] = os.path.join(base_folder, base_name + extension)
                    media_dict[f"{key}_dest"] = os.path.join(DEST_FOLDER, "ES-DE", "downloaded_media", get_system_name(system), media_table[key], rom_name + extension)

            # Asignar el diccionario "media" al elemento
            element["media"] = media_dict

            # Añadir el elemento a la lista de ficheros
            file_list.append(element)
            print(system + " - " + rom_name)

        # Gestiona el fichero "gamelist.xml"
        file_name = "gamelist.xml"
        gamelist = os.path.join(folder, file_name)
        if os.path.isfile(gamelist):
            element = {}
            element["name"] = "gamelist"
            element["rom_source"] = os.path.join(folder, file_name)
            element["rom_dest"] = os.path.join(DEST_FOLDER, "ES-DE", "gamelists", system, file_name)
            file_list.append(element)

    return file_list


def copy_file(source_path, dest_path):
    """
    Copia un archivo desde la ruta source_path a dest_path, creando directorios si es necesario.
    Si el archivo de destino ya existe, no hace nada.
    Si el archivo tiene una extensión no permitida, no lo copia.
    Si el archivo es un .xml, se usa un método especial para copiarlo.
    """
    # Lista de extensiones no permitidas
    forbidden_extensions = [".mp4"]

    if not source_path or not dest_path:
        print(f"Source o destino inválido: {source_path}, {dest_path}. Saltando...")
        return

    # Verificar si el archivo tiene una extensión no permitida
    _, extension = os.path.splitext(source_path)
    if extension in forbidden_extensions:
        print(f"Archivo con extensión no permitida ({extension}): {source_path}. Saltando...")
        return

    # Manejo especial para archivos .xml
    if extension == ".xml":
        copy_xml_file(source_path, dest_path)  # Llamar al método especial para XML
        return

    # Crear el directorio de destino si no existe
    dest_dir = os.path.dirname(dest_path)
    if not os.path.exists(dest_dir):
        os.makedirs(dest_dir)
        print(f"Directorio creado: {dest_dir}")

    # Verificar si el archivo de destino ya existe
    if os.path.exists(dest_path):
        print(f"El archivo ya existe: {dest_path}. No se realiza la copia.")
        return

    # Copiar el archivo
    try:
        shutil.copy2(source_path, dest_path)  # Usa copy2 para preservar metadata
        print(f"Copiado: {source_path} -> {dest_path}")
    except FileNotFoundError:
        print(f"Archivo fuente no encontrado: {source_path}. Saltando...")
    except Exception as e:
        print(f"Error al copiar {source_path} a {dest_path}: {e}")


def copy_xml_file(source_path, dest_path):
    """
    Copia un archivo XML omitiendo las líneas que contienen ciertos textos no deseados.
    """
    # Lista de textos a omitir
    texts_to_omit = ["<image>", "<wheel>", "<boxart>", "<screenshot>", "<cartridge>", "<mix>", "<video>", "<marquee>", "<thumbnail />"]

    # Crear el directorio de destino si no existe
    dest_dir = os.path.dirname(dest_path)
    if not os.path.exists(dest_dir):
        os.makedirs(dest_dir)
        print(f"Directorio creado: {dest_dir}")

    try:
        # Leer el archivo fuente y escribir solo las líneas permitidas en el archivo destino
        with open(source_path, "r", encoding="utf-8") as source_file, open(dest_path, "w", encoding="utf-8") as dest_file:
            for line in source_file:
                # Si ninguna de las etiquetas a omitir está en la línea, escríbela en el destino
                if not any(text in line for text in texts_to_omit):
                    dest_file.write(line)
        
        print(f"Archivo XML procesado y copiado: {source_path} -> {dest_path}")
    except FileNotFoundError:
        print(f"Archivo XML fuente no encontrado: {source_path}. Saltando...")
    except Exception as e:
        print(f"Error al procesar el archivo XML {source_path} a {dest_path}: {e}")


def copy_files_with_structure(data):
    """
    Copia los archivos apuntados por las claves *_source a sus homólogos *_dest.
    Incluye rom_source y rom_dest. Crea las carpetas de destino si no existen.
    """
    # Manejar archivos de media (claves *_source y *_dest)
    if "media" in data:
        for key, source_path in data["media"].items():
            if key.endswith("_source"):
                # Buscar la clave _dest correspondiente
                dest_key = key.replace("_source", "_dest")
                dest_path = data["media"].get(dest_key)
                copy_file(source_path, dest_path)

    # Manejar archivo de rom_source -> rom_dest
    if "rom_source" in data and "rom_dest" in data:
        copy_file(data["rom_source"], data["rom_dest"])


def main():
    """Función principal del programa."""
    file_list = create_file_list()    
    # pprint.pprint(file_list, width=200)
    for game in file_list:
        copy_files_with_structure(game)

# Verifica si este archivo se ejecuta como script principal
if __name__ == "__main__":
    main()