class EqualiseurAudio:
  def __init__(self, master):
    self.master = master
    master.title("Égaliseur Audio")

    self.audio_segment = None
    self.playback = None

    # Volume
    self.volume_frame = tk.Frame(master)
    self.volume_frame.pack()
    tk.Label(self.volume_frame, text="Volume:").pack(side=tk.LEFT)
    self.volume_scale = tk.Scale(self.volume_frame, from_=0, to=2, resolution=0.1, orient=tk.HORIZONTAL, command=self.changer_volume)
    self.volume_scale.set(1)  # Volume initial
    self.volume_scale.pack(side=tk.LEFT)

    # Effet Binaural
    self.binaural_var = tk.BooleanVar()
    tk.Checkbutton(master, text="Effet Binaural", variable=self.binaural_var, command=self.appliquer_effet_binaural).pack()

    # Effet Acoustique (Réverbération - exemple simple)
    self.reverb_var = tk.BooleanVar()
    tk.Checkbutton(master, text="Réverbération", variable=self.reverb_var, command=self.appliquer_reverb).pack()

    # Bass Boost
    self.bass_boost_frame = tk.Frame(master)
    self.bass_boost_frame.pack()
    tk.Label(self.bass_boost_frame, text="Bass Boost:").pack(side=tk.LEFT)
    self.bass_boost_scale = tk.Scale(self.bass_boost_frame, from_=0, to=10, orient=tk.HORIZONTAL, command=self.appliquer_bass_boost)
    self.bass_boost_scale.set(0)
    self.bass_boost_scale.pack(side=tk.LEFT)

    # 3D Surround (Panoramique Stéréo - exemple simple)
    self.surround_frame = tk.Frame(master)
    self.surround_frame.pack()
    tk.Label(self.surround_frame, text="3D Surround:").pack(side=tk.LEFT)
    self.surround_scale = tk.Scale(self.surround_frame, from_=-1, to=1, resolution=0.1, orient=tk.HORIZONTAL, command=self.appliquer_3d_surround)
    self.surround_scale.set(0) # Centre par défaut
    self.surround_scale.pack(side=tk.LEFT)

    # Son 8D (Panoramique Cyclique - exemple simple)
    self.son_8d_var = tk.BooleanVar()
    tk.Checkbutton(master, text="Son 8D", variable=self.son_8d_var, command=self.appliquer_son_8d).pack()


    # Bouton Ouvrir Fichier
    self.ouvrir_bouton = tk.Button(master, text="Ouvrir Fichier Audio", command=self.ouvrir_fichier)
    self.ouvrir_bouton.pack()

    # Bouton Play/Pause
    self.play_pause_bouton = tk.Button(master, text="Play", command=self.play_pause_audio)
    self.play_pause_bouton.pack()
    self.is_playing = False


  def ouvrir_fichier(self):
    chemin_fichier = filedialog.askopenfilename(
        defaultextension=".wav",
        filetypes=[("Fichiers Audio", "*.wav *.mp3 *.flac *.ogg")]
    )
    if chemin_fichier:
      try:
        self.audio_segment = AudioSegment.from_file(chemin_fichier)
        print(f"Fichier audio ouvert: {chemin_fichier}")
      except Exception as e:
        tk.messagebox.showerror("Erreur", f"Impossible d'ouvrir le fichier audio: {e}")

  def play_pause_audio(self):
    if self.audio_segment:
      if not self.is_playing:
        self.play_audio()
      else:
        self.pause_audio()
    else:
      tk.messagebox.showinfo("Info", "Veuillez d'abord ouvrir un fichier audio.")

  def play_audio(self):
    if self.audio_segment:
      if self.playback and self.playback.is_playing():
          self.playback.stop()

      frame_rate = self.audio_segment.frame_rate
      num_channels = self.audio_segment.channels
      sample_width = self.audio_segment.sample_width
      audio_data = np.array(self.audio_segment.get_array_of_samples())

      # Appliquer les effets (dans l'ordre)
      audio_data = self.appliquer_volume_audio(audio_data)
      if self.binaural_var.get():
          audio_data = self.appliquer_effet_binaural_audio(audio_data, frame_rate, num_channels)
      if self.reverb_var.get():
          audio_data = self.appliquer_reverb_audio(audio_data, frame_rate)
      bass_boost_level = self.bass_boost_scale.get()
      if bass_boost_level > 0:
          audio_data = self.appliquer_bass_boost_audio(audio_data, frame_rate, bass_boost_level)
      surround_level = self.surround_scale.get()
      if surround_level != 0:
          audio_data = self.appliquer_3d_surround_audio(audio_data, num_channels, surround_level)
      if self.son_8d_var.get():
          audio_data = self.appliquer_son_8d_audio(audio_data, frame_rate, num_channels)


      # Assurer que les données audio sont dans la plage appropriée pour simpleaudio
      audio_data = np.clip(audio_data, -2**(8*sample_width-1), 2**(8*sample_width-1)-1).astype(np.int16)


      play_audio_data = audio_data.tobytes()


      try:
          self.playback = sa.play_buffer(play_audio_data, num_channels, sample_width, frame_rate)
          self.play_pause_bouton.config(text="Pause")
          self.is_playing = True
      except Exception as e:
          tk.messagebox.showerror("Erreur de Lecture", f"Erreur lors de la lecture audio: {e}")


  def pause_audio(self):
      if self.playback and self.playback.is_playing():
          self.playback.stop()
          self.play_pause_bouton.config(text="Play")
          self.is_playing = False


  def changer_volume(self, volume):
      # Le volume est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_volume_audio(self, audio_data):
      volume_niveau = self.volume_scale.get()
      return audio_data * volume_niveau

  def appliquer_effet_binaural(self):
      # L'effet binaural est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_effet_binaural_audio(self, audio_data, frame_rate, num_channels):
      if num_channels == 1: # Binauralisation stéréo uniquement
          canal_gauche = audio_data
          canal_droit = audio_data
          # Filtrage HRTF pourrait être appliqué ici pour un effet binaural plus réaliste
          return np.column_stack((canal_gauche, canal_droit))
      return audio_data # Si déjà stéréo, on ne fait rien (ou on pourrait envisager un traitement binaural spécifique)


  def appliquer_reverb(self):
      # La réverbération est appliquée lors de la lecture dans play_audio
      pass

  def appliquer_reverb_audio(self, audio_data, frame_rate):
      # Exemple simple de réverbération (délai et atténuation)
      delay = int(0.1 * frame_rate) # Délai de 0.1 seconde
      attenuation = 0.5
      reverb_signal = np.zeros_like(audio_data)
      reverb_signal[delay:] += audio_data[:-delay] * attenuation
      return audio_data + reverb_signal


  def appliquer_bass_boost(self, niveau):
      # Bass boost est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_bass_boost_audio(self, audio_data, frame_rate, niveau):
      # Exemple simple de Bass Boost (filtre passe-bas)
      cutoff_freq = 200 # Hz, fréquence de coupure pour les basses
      b, a = scipy.signal.butter(4, cutoff_freq / (frame_rate / 2), btype='low') # Filtre Butterworth
      boost_factor = 1 + (niveau / 10.0) # Facteur d'amplification basé sur le niveau
      filtered_signal = scipy.signal.lfilter(b, a, audio_data)
      return audio_data + filtered_signal * boost_factor # Ajouter le signal filtré amplifié à l'original


  def appliquer_3d_surround(self):
      # 3D Surround est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_3d_surround_audio(self, audio_data, num_channels, niveau_panoramique):
      if num_channels == 2: # Panoramique stéréo uniquement
          canal_gauche = audio_data[:, 0]
          canal_droit = audio_data[:, 1]
          if niveau_panoramique > 0: # Déplacer vers la droite
              canal_droit = canal_droit * (1 + niveau_panoramique)
              canal_gauche = canal_gauche * (1 - niveau_panoramique)
          elif niveau_panoramique < 0: # Déplacer vers la gauche
              canal_gauche = canal_gauche * (1 - niveau_panoramique) # Moins négatif = plus fort
              canal_droit = canal_droit * (1 + niveau_panoramique) # Plus négatif = moins fort
          return np.column_stack((canal_gauche, canal_droit))
      return audio_data # Si mono, on ne fait rien


  def appliquer_son_8d(self):
      # Son 8D est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_son_8d_audio(self, audio_data, frame_rate, num_channels):
      if num_channels == 2: # Son 8D stéréo uniquement
          canal_gauche = audio_data[:, 0]
          canal_droit = audio_data[:, 1]
          duree = len(audio_data) / frame_rate # Durée en secondes
          frequence_panoramique = 0.2 # Hz, vitesse de panoramique
          temps = np.linspace(0, duree, len(audio_data), endpoint=False)
          modulation_panoramique = np.sin(2 * np.pi * frequence_panoramique * temps)
          canal_gauche_modifie = canal_gauche * (1 - modulation_panoramique)
          canal_droit_modifie = canal_droit * (1 + modulation_panoramique)
          return np.column_stack((canal_gauche_modifie, canal_droit_modifie))
      return audio_data # Si mono, on ne fait rien


if __name__ == "__main__":
  root = tk.Tk()
  equaliseur = EqualiseurAudio(root)
  root.mainloop()

class EqualiseurAudio:
  def __init__(self, master):
    self.master = master
    master.title("Égaliseur Audio")

    self.audio_segment = None
    self.playback = None

    # Volume
    self.volume_frame = tk.Frame(master)
    self.volume_frame.pack()
    tk.Label(self.volume_frame, text="Volume:").pack(side=tk.LEFT)
    self.volume_scale = tk.Scale(self.volume_frame, from_=0, to=2, resolution=0.1, orient=tk.HORIZONTAL, command=self.changer_volume)
    self.volume_scale.set(1)  # Volume initial
    self.volume_scale.pack(side=tk.LEFT)

    # Effet Binaural
    self.binaural_var = tk.BooleanVar()
    tk.Checkbutton(master, text="Effet Binaural", variable=self.binaural_var, command=self.appliquer_effet_binaural).pack()

    # Effet Acoustique (Réverbération - exemple simple)
    self.reverb_var = tk.BooleanVar()
    tk.Checkbutton(master, text="Réverbération", variable=self.reverb_var, command=self.appliquer_reverb).pack()

    # Bass Boost
    self.bass_boost_frame = tk.Frame(master)
    self.bass_boost_frame.pack()
    tk.Label(self.bass_boost_frame, text="Bass Boost:").pack(side=tk.LEFT)
    self.bass_boost_scale = tk.Scale(self.bass_boost_frame, from_=0, to=10, orient=tk.HORIZONTAL, command=self.appliquer_bass_boost)
    self.bass_boost_scale.set(0)
    self.bass_boost_scale.pack(side=tk.LEFT)

    # 3D Surround (Panoramique Stéréo - exemple simple)
    self.surround_frame = tk.Frame(master)
    self.surround_frame.pack()
    tk.Label(self.surround_frame, text="3D Surround:").pack(side=tk.LEFT)
    self.surround_scale = tk.Scale(self.surround_frame, from_=-1, to=1, resolution=0.1, orient=tk.HORIZONTAL, command=self.appliquer_3d_surround)
    self.surround_scale.set(0) # Centre par défaut
    self.surround_scale.pack(side=tk.LEFT)

    # Son 8D (Panoramique Cyclique - exemple simple)
    self.son_8d_var = tk.BooleanVar()
    tk.Checkbutton(master, text="Son 8D", variable=self.son_8d_var, command=self.appliquer_son_8d).pack()


    # Bouton Ouvrir Fichier
    self.ouvrir_bouton = tk.Button(master, text="Ouvrir Fichier Audio", command=self.ouvrir_fichier)
    self.ouvrir_bouton.pack()

    # Bouton Play/Pause
    self.play_pause_bouton = tk.Button(master, text="Play", command=self.play_pause_audio)
    self.play_pause_bouton.pack()
    self.is_playing = False


  def ouvrir_fichier(self):
    chemin_fichier = filedialog.askopenfilename(
        defaultextension=".wav",
        filetypes=[("Fichiers Audio", "*.wav *.mp3 *.flac *.ogg")]
    )
    if chemin_fichier:
      try:
        self.audio_segment = AudioSegment.from_file(chemin_fichier)
        print(f"Fichier audio ouvert: {chemin_fichier}")
      except Exception as e:
        tk.messagebox.showerror("Erreur", f"Impossible d'ouvrir le fichier audio: {e}")

  def play_pause_audio(self):
    if self.audio_segment:
      if not self.is_playing:
        self.play_audio()
      else:
        self.pause_audio()
    else:
      tk.messagebox.showinfo("Info", "Veuillez d'abord ouvrir un fichier audio.")

  def play_audio(self):
    if self.audio_segment:
      if self.playback and self.playback.is_playing():
          self.playback.stop()

      frame_rate = self.audio_segment.frame_rate
      num_channels = self.audio_segment.channels
      sample_width = self.audio_segment.sample_width
      audio_data = np.array(self.audio_segment.get_array_of_samples())

      # Appliquer les effets (dans l'ordre)
      audio_data = self.appliquer_volume_audio(audio_data)
      if self.binaural_var.get():
          audio_data = self.appliquer_effet_binaural_audio(audio_data, frame_rate, num_channels)
      if self.reverb_var.get():
          audio_data = self.appliquer_reverb_audio(audio_data, frame_rate)
      bass_boost_level = self.bass_boost_scale.get()
      if bass_boost_level > 0:
          audio_data = self.appliquer_bass_boost_audio(audio_data, frame_rate, bass_boost_level)
      surround_level = self.surround_scale.get()
      if surround_level != 0:
          audio_data = self.appliquer_3d_surround_audio(audio_data, num_channels, surround_level)
      if self.son_8d_var.get():
          audio_data = self.appliquer_son_8d_audio(audio_data, frame_rate, num_channels)


      # Assurer que les données audio sont dans la plage appropriée pour simpleaudio
      audio_data = np.clip(audio_data, -2**(8*sample_width-1), 2**(8*sample_width-1)-1).astype(np.int16)


      play_audio_data = audio_data.tobytes()


      try:
          self.playback = sa.play_buffer(play_audio_data, num_channels, sample_width, frame_rate)
          self.play_pause_bouton.config(text="Pause")
          self.is_playing = True
      except Exception as e:
          tk.messagebox.showerror("Erreur de Lecture", f"Erreur lors de la lecture audio: {e}")


  def pause_audio(self):
      if self.playback and self.playback.is_playing():
          self.playback.stop()
          self.play_pause_bouton.config(text="Play")
          self.is_playing = False


  def changer_volume(self, volume):
      # Le volume est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_volume_audio(self, audio_data):
      volume_niveau = self.volume_scale.get()
      return audio_data * volume_niveau

  def appliquer_effet_binaural(self):
      # L'effet binaural est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_effet_binaural_audio(self, audio_data, frame_rate, num_channels):
      if num_channels == 1: # Binauralisation stéréo uniquement
          canal_gauche = audio_data
          canal_droit = audio_data
          # Filtrage HRTF pourrait être appliqué ici pour un effet binaural plus réaliste
          return np.column_stack((canal_gauche, canal_droit))
      return audio_data # Si déjà stéréo, on ne fait rien (ou on pourrait envisager un traitement binaural spécifique)


  def appliquer_reverb(self):
      # La réverbération est appliquée lors de la lecture dans play_audio
      pass

  def appliquer_reverb_audio(self, audio_data, frame_rate):
      # Exemple simple de réverbération (délai et atténuation)
      delay = int(0.1 * frame_rate) # Délai de 0.1 seconde
      attenuation = 0.5
      reverb_signal = np.zeros_like(audio_data)
      reverb_signal[delay:] += audio_data[:-delay] * attenuation
      return audio_data + reverb_signal


  def appliquer_bass_boost(self, niveau):
      # Bass boost est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_bass_boost_audio(self, audio_data, frame_rate, niveau):
      # Exemple simple de Bass Boost (filtre passe-bas)
      cutoff_freq = 200 # Hz, fréquence de coupure pour les basses
      b, a = scipy.signal.butter(4, cutoff_freq / (frame_rate / 2), btype='low') # Filtre Butterworth
      boost_factor = 1 + (niveau / 10.0) # Facteur d'amplification basé sur le niveau
      filtered_signal = scipy.signal.lfilter(b, a, audio_data)
      return audio_data + filtered_signal * boost_factor # Ajouter le signal filtré amplifié à l'original


  def appliquer_3d_surround(self):
      # 3D Surround est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_3d_surround_audio(self, audio_data, num_channels, niveau_panoramique):
      if num_channels == 2: # Panoramique stéréo uniquement
          canal_gauche = audio_data[:, 0]
          canal_droit = audio_data[:, 1]
          if niveau_panoramique > 0: # Déplacer vers la droite
              canal_droit = canal_droit * (1 + niveau_panoramique)
              canal_gauche = canal_gauche * (1 - niveau_panoramique)
          elif niveau_panoramique < 0: # Déplacer vers la gauche
              canal_gauche = canal_gauche * (1 - niveau_panoramique) # Moins négatif = plus fort
              canal_droit = canal_droit * (1 + niveau_panoramique) # Plus négatif = moins fort
          return np.column_stack((canal_gauche, canal_droit))
      return audio_data # Si mono, on ne fait rien


  def appliquer_son_8d(self):
      # Son 8D est appliqué lors de la lecture dans play_audio
      pass

  def appliquer_son_8d_audio(self, audio_data, frame_rate, num_channels):
      if num_channels == 2: # Son 8D stéréo uniquement
          canal_gauche = audio_data[:, 0]
          canal_droit = audio_data[:, 1]
          duree = len(audio_data) / frame_rate # Durée en secondes
          frequence_panoramique = 0.2 # Hz, vitesse de panoramique
          temps = np.linspace(0, duree, len(audio_data), endpoint=False)
          modulation_panoramique = np.sin(2 * np.pi * frequence_panoramique * temps)
          canal_gauche_modifie = canal_gauche * (1 - modulation_panoramique)
          canal_droit_modifie = canal_droit * (1 + modulation_panoramique)
          return np.column_stack((canal_gauche_modifie, canal_droit_modifie))
      return audio_data # Si mono, on ne fait rien


if __name__ == "__main__":
  root = tk.Tk()
  equaliseur = EqualiseurAudio(root)
  root.mainloop()