#coding: utf-8
from pydub import AudioSegment
#from openai import OpenAI
#from io import BytesIO
#from typing import Any
#from typing import Dict
#from typing import IO
from typing import List
from typing import Optional
from typing import Tuple
from typing import Union
import base64
import io

def concatenate_audio_files(audio_list: List[Tuple[Union[bytes, str], float]]) -> Optional[bytes]:
    """
    Concatène plusieurs fichiers audio avec des effets sonores.

    Args:
        audio_list (List[Tuple[Union[bytes, str], float]]): Une liste de tuples, chacun contenant
            des octets audio (ou une chaîne base64) et la durée.

    Returns:
        Optional[bytes]: L'audio concaténé sous forme d'octets, ou None en cas d'erreur.
    """
    # Créer un segment audio vide
    final_audio = AudioSegment.empty()
    
    try:
        # Charger les effets sonores
        begin_sound = AudioSegment.from_mp3(
            "sound-effects/voice-message-play-begin/voice-message-play-begin-1.mp3"
        )
        end_sound = AudioSegment.from_mp3(
            "sound-effects/voice-message-play-ending/voice-message-play-ending-1.mp3"
        )
        
        # 5 secondes de silence
        silence = AudioSegment.silent(duration=1500)  # 1500 ms = 1.5 secondes
        
        for audio_data, _ in audio_list:
            # Convertir en bytes si c'est une chaîne base64
            if isinstance(audio_data, str):
                audio_bytes = base64.b64decode(audio_data)
            else:
                audio_bytes = audio_data

            # Convertir les octets en un segment audio
            segment = AudioSegment.from_mp3(io.BytesIO(audio_bytes))
            
            # Ajouter le son de début, le segment TTS, le son de fin et le silence
            final_audio += begin_sound + segment + end_sound + silence
        
        
        # Convertir le segment audio final en octets
        buffer = io.BytesIO()
        final_audio.export(buffer, format="mp3")
        return buffer.getvalue()
    except IOError as e:
        print(f"Erreur lors de la lecture ou de l'écriture des fichiers audio : {e}")
        return None
    except Exception as e:
        print(f"Une erreur inattendue s'est produite : {e}")
        return None


def split_audio(audio_file, max_size_mb: int = 25) -> List[bytes]:
    """
    Divise un fichier audio en segments de taille maximale spécifiée.

    Args:
        audio_file: Fichier audio ouvert en mode binaire.
        max_size_mb (int): Taille maximale de chaque segment en Mo.

    Returns:
        List[bytes]: Liste des segments audio divisés sous forme de bytes.
    """
    try:
        audio_file.seek(0)
        audio = AudioSegment.from_file(audio_file)
        duration_ms = len(audio)
        segment_duration_ms = int(
            (max_size_mb * 1024 * 1024 * 8) /
            (audio.frame_rate * audio.sample_width * audio.channels)
        )

        segments = []
        for start in range(0, duration_ms, segment_duration_ms):
            end = min(start + segment_duration_ms, duration_ms)
            segment = audio[start:end]
            
            with io.BytesIO() as buffer:
                segment.export(buffer, format="mp3")
                segments.append(buffer.getvalue())

        return segments
    except Exception as e:
        print(f"Une erreur s'est produite lors de la division de l'audio : {e}")
        return []