app.py

from flask import Flask, render_template, request, redirect, url_for, flash, jsonify, send_from_directory
from flask_sqlalchemy import SQLAlchemy
import os
import requests
from urllib.parse import urlparse
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = Flask(__name__)
app.secret_key = os.environ.get('FLASK_SECRET_KEY', 'une_cle_secrete_par_defaut_pour_dev')

app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://Podcast_owner:npg_gFdMDLO9lVa0@ep-delicate-surf-a4v7wopn-pooler.us-east-1.aws.neon.tech/Podcast?sslmode=require'

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

AUDIO_CACHE_DIR = '/tmp/audio_cache'
try:
    os.makedirs(AUDIO_CACHE_DIR, exist_ok=True)
    logger.info(f"Répertoire de cache audio configuré sur : {AUDIO_CACHE_DIR}")
except OSError as e:
    logger.error(f"Impossible de créer le répertoire de cache audio à {AUDIO_CACHE_DIR}: {e}")

class Podcast(db.Model):
    __tablename__ = 'podcast'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(200), nullable=False)
    url = db.Column(db.String(500), nullable=False, unique=True)
    subject = db.Column(db.String(100), nullable=False)
    filename_cache = db.Column(db.String(255), nullable=True)

    def __repr__(self):
        return f'<Podcast {self.name}>'

@app.route('/')
def index():
    try:
        podcasts = Podcast.query.order_by(Podcast.name).all()
    except Exception as e:
        logger.error(f"Erreur lors de la récupération des podcasts: {e}")
        flash("Erreur lors du chargement des podcasts depuis la base de données.", "error")
        podcasts = []
    return render_template('index.html', podcasts=podcasts)

@app.route('/gestion', methods=['GET', 'POST'])
def gestion():
    if request.method == 'POST':
        name = request.form.get('name')
        url = request.form.get('url')
        subject = request.form.get('subject')

        if not name or not url or not subject:
            flash('Tous les champs sont requis !', 'error')
        else:
            existing_podcast = Podcast.query.filter_by(url=url).first()
            if existing_podcast:
                flash('Un podcast avec cette URL existe déjà.', 'warning')
            else:
                try:
                    new_podcast = Podcast(name=name, url=url, subject=subject)
                    db.session.add(new_podcast)
                    db.session.commit()
                    flash('Podcast ajouté avec succès !', 'success')
                    return redirect(url_for('gestion'))
                except Exception as e:
                    db.session.rollback()
                    logger.error(f"Erreur lors de l'ajout du podcast: {e}")
                    flash(f"Erreur lors de l'ajout du podcast: {e}", 'error')
    
    try:
        podcasts = Podcast.query.order_by(Podcast.name).all()
    except Exception as e:
        logger.error(f"Erreur lors de la récupération des podcasts pour la gestion: {e}")
        flash("Erreur lors du chargement des podcasts pour la gestion.", "error")
        podcasts = []
        
    return render_template('gestion.html', podcasts=podcasts)

@app.route('/delete_podcast/<int:podcast_id>', methods=['POST'])
def delete_podcast(podcast_id):
    try:
        podcast_to_delete = db.session.get(Podcast, podcast_id)
        if not podcast_to_delete:
            flash('Podcast non trouvé.', 'error')
            return redirect(url_for('gestion'))

        if podcast_to_delete.filename_cache:
            cached_file_path = os.path.join(AUDIO_CACHE_DIR, podcast_to_delete.filename_cache)
            if os.path.exists(cached_file_path):
                try:
                    os.remove(cached_file_path)
                    logger.info(f"Fichier cache {podcast_to_delete.filename_cache} supprimé.")
                except OSError as e:
                    logger.error(f"Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}: {e}")
                    flash(f'Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}.', 'error')

        db.session.delete(podcast_to_delete)
        db.session.commit()
        flash('Podcast supprimé avec succès.', 'success')
    except Exception as e:
        db.session.rollback()
        logger.error(f"Erreur lors de la suppression du podcast ID {podcast_id}: {e}")
        flash(f"Erreur lors de la suppression du podcast: {e}", 'error')
    return redirect(url_for('gestion'))

@app.route('/play/<int:podcast_id>')
def play_podcast_route(podcast_id):
    podcast = db.session.get(Podcast, podcast_id)

    if not podcast:
        logger.warning(f"Tentative de lecture d'un podcast non trouvé: ID {podcast_id}")
        return jsonify({'error': 'Podcast non trouvé'}), 404

    if podcast.filename_cache:
        cached_filepath = os.path.join(AUDIO_CACHE_DIR, podcast.filename_cache)
        if os.path.exists(cached_filepath):
            logger.info(f"Service du podcast {podcast.id} depuis le cache: {podcast.filename_cache}")
            audio_url = url_for('serve_cached_audio', filename=podcast.filename_cache)
            return jsonify({'audio_url': audio_url})
        else:
            logger.warning(f"Fichier cache {podcast.filename_cache} pour podcast {podcast.id} non trouvé. Re-téléchargement.")
            podcast.filename_cache = None

    final_cached_filepath = None
    try:
        parsed_url = urlparse(podcast.url)
        path_parts = os.path.splitext(parsed_url.path)
        extension = path_parts[1] if path_parts[1] else '.audio'
        
        base_filename = str(podcast.id)
        
        logger.info(f"Téléchargement de {podcast.url} pour le podcast ID {podcast.id}")
        response = requests.get(podcast.url, stream=True, timeout=(10, 60))
        response.raise_for_status()

        content_type = response.headers.get('Content-Type')
        if content_type:
            if 'mpeg' in content_type: extension = '.mp3'
            elif 'ogg' in content_type: extension = '.ogg'
            elif 'wav' in content_type: extension = '.wav'
            elif 'aac' in content_type: extension = '.aac'
            elif 'mp4' in content_type: extension = '.m4a'

        cached_filename_with_ext = f"{base_filename}{extension}"
        final_cached_filepath = os.path.join(AUDIO_CACHE_DIR, cached_filename_with_ext)

        with open(final_cached_filepath, 'wb') as f:
            for chunk in response.iter_content(chunk_size=8192):
                f.write(chunk)
        logger.info(f"Téléchargement terminé: {final_cached_filepath}")

        podcast.filename_cache = cached_filename_with_ext
        db.session.commit()
        
        audio_url = url_for('serve_cached_audio', filename=cached_filename_with_ext)
        return jsonify({'audio_url': audio_url})

    except requests.exceptions.Timeout:
        logger.error(f"Timeout lors du téléchargement de {podcast.url}")
        return jsonify({'error': 'Le téléchargement du podcast a pris trop de temps.'}), 504
    except requests.exceptions.RequestException as e:
        logger.error(f"Erreur de téléchargement pour {podcast.url}: {e}")
        return jsonify({'error': f'Impossible de télécharger le podcast: {e}'}), 500
    except Exception as e:
        db.session.rollback()
        logger.error(f"Erreur inattendue lors du traitement du podcast {podcast.id}: {e}")
        return jsonify({'error': f'Erreur inattendue: {e}'}), 500
    finally:
        if final_cached_filepath and os.path.exists(final_cached_filepath) and (not podcast or podcast.filename_cache != os.path.basename(final_cached_filepath)):
            try:
                os.remove(final_cached_filepath)
                logger.info(f"Fichier partiel nettoyé : {final_cached_filepath}")
            except OSError as e_clean:
                logger.error(f"Erreur lors du nettoyage du fichier partiel {final_cached_filepath}: {e_clean}")

@app.route('/audio_cache/<path:filename>')
def serve_cached_audio(filename):
    logger.debug(f"Service du fichier cache: {filename} depuis {AUDIO_CACHE_DIR}")
    return send_from_directory(AUDIO_CACHE_DIR, filename)

if __name__ == '__main__':
    with app.app_context():
        try:
            db.create_all()
            logger.info("Tables de base de données vérifiées/créées (si elles n'existaient pas).")
        except Exception as e:
            logger.error(f"Erreur lors de la création des tables de la base de données: {e}")
            logger.error("Assurez-vous que votre serveur PostgreSQL est en cours d'exécution et que la base de données existe.")
    app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))