//! Structures pour les jobs d'encodage audio
//!
//! Ce module définit les structures de données pour gérer les jobs d'encodage
//! audio via FFmpeg, avec support pour différents codecs et qualités.

use crate::transcoding::codecs::AudioCodec;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use uuid::Uuid;

/// Job d'encodage audio pour un track spécifique
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EncodeJob {
    /// ID du track à encoder
    pub track_id: Uuid,
    /// Chemin vers le fichier source audio
    pub input_path: PathBuf,
    /// Répertoire de sortie pour les segments HLS
    pub output_dir: PathBuf,
    /// Codec audio à utiliser (AAC, Opus, MP3, FLAC)
    pub codec: AudioCodec,
    /// Bitrate en bps (ex: 128000 pour 128kbps)
    pub bitrate: u32,
    /// Qualité (low, medium, high, hi_res)
    pub quality: String,
    /// Sample rate en Hz (ex: 44100)
    pub sample_rate: u32,
    /// Nombre de canaux (1 = mono, 2 = stéréo)
    pub channels: u8,
    /// Durée du segment HLS en secondes
    pub hls_segment_time: u32,
}

impl EncodeJob {
    /// Crée un nouveau job d'encodage
    pub fn new(
        track_id: Uuid,
        input_path: PathBuf,
        output_dir: PathBuf,
        codec: AudioCodec,
        bitrate: u32,
        quality: String,
        sample_rate: u32,
        channels: u8,
        hls_segment_time: u32,
    ) -> Self {
        Self {
            track_id,
            input_path,
            output_dir,
            codec,
            bitrate,
            quality,
            sample_rate,
            channels,
            hls_segment_time,
        }
    }

    /// Crée un job depuis un profil de qualité
    pub fn from_quality_profile(
        track_id: Uuid,
        input_path: PathBuf,
        output_dir: PathBuf,
        quality: String,
    ) -> Self {
        let (codec, bitrate, sample_rate, channels, hls_segment_time) = match quality.as_str() {
            "low" => (AudioCodec::AAC, 64_000, 22_050, 1, 4),
            "medium" => (AudioCodec::AAC, 128_000, 44_100, 2, 4),
            "high" => (AudioCodec::AAC, 192_000, 44_100, 2, 4),
            "hi_res" => (AudioCodec::AAC, 320_000, 48_000, 2, 4),
            _ => (AudioCodec::AAC, 128_000, 44_100, 2, 4), // Default: medium
        };

        Self::new(
            track_id,
            input_path,
            output_dir,
            codec,
            bitrate,
            quality,
            sample_rate,
            channels,
            hls_segment_time,
        )
    }
}

/// Statut d'un job d'encodage
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum EncodeJobStatus {
    Pending,
    Encoding,
    Done,
    Error,
}

impl EncodeJobStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            EncodeJobStatus::Pending => "pending",
            EncodeJobStatus::Encoding => "encoding",
            EncodeJobStatus::Done => "done",
            EncodeJobStatus::Error => "error",
        }
    }

    pub fn from_str(s: &str) -> Option<Self> {
        match s {
            "pending" => Some(EncodeJobStatus::Pending),
            "encoding" => Some(EncodeJobStatus::Encoding),
            "done" => Some(EncodeJobStatus::Done),
            "error" => Some(EncodeJobStatus::Error),
            _ => None,
        }
    }
}

