//! Kokoro TTS plugin (stub).
//!
//! Kokoro is a lightweight, open-source TTS model. This stub shows the pattern for
//! adding a new engine plugin: implement [`TtsEngine`] and wire the HTTP or
//! local inference calls.
//!
//! # Configuration
//! Set `TTS_ENGINE=kokoro` and provide:
//! - `KOKORO_URL` — base URL of the Kokoro HTTP server (default: `http://localhost:8880`)
//! - `KOKORO_VOICE` — voice name (default: `af_heart`)
//!
//! # Resampling note
//! Kokoro typically outputs at 24 kHz. Since the mixer runs at
//! [`crate::config::OUTPUT_SAMPLE_RATE`] (44.1 kHz), this plugin must
//! resample internally before pushing samples. A basic linear resampler is
//! provided below; replace with a polyphase/FIR resampler for higher quality.

use crate::audio::SampleRingBuffer;
use crate::config::{Config, OUTPUT_SAMPLE_RATE};
use crate::tts::TtsEngine;
use anyhow::Result;
use async_trait::async_trait;
use std::sync::Arc;
use tokio_util::sync::CancellationToken;
use tracing::info;

/// Kokoro native output sample rate (Hz).
const KOKORO_SAMPLE_RATE: u32 = 24_000;

/// Kokoro TTS plugin.
#[derive(Clone)]
pub struct KokoroTts {
    endpoint: String,
    voice: String,
    http: reqwest::Client,
    _config: Arc<Config>,
}

impl KokoroTts {
    pub fn new(config: &Config) -> Self {
        let endpoint = std::env::var("KOKORO_URL")
            .unwrap_or_else(|_| "http://localhost:8880".to_string());
        let voice = std::env::var("KOKORO_VOICE")
            .unwrap_or_else(|_| "af_heart".to_string());
        info!(endpoint = %endpoint, voice = %voice, "Kokoro TTS plugin initialized");
        Self {
            endpoint,
            voice,
            http: reqwest::Client::builder()
                .build()
                .expect("failed to build reqwest client"),
            _config: Arc::new(config.clone()),
        }
    }
}

#[async_trait]
impl TtsEngine for KokoroTts {
    fn name(&self) -> &str {
        "kokoro"
    }

    fn sample_rate(&self) -> u32 {
        // We resample to the mixer rate before pushing.
        OUTPUT_SAMPLE_RATE
    }

    async fn synthesize(
        &self,
        text: &str,
        tts_queue: &SampleRingBuffer,
        cancel: &CancellationToken,
    ) -> Result<()> {
        // TODO: implement the actual Kokoro HTTP streaming call.
        //
        // Example request (adjust to be completed by the user):
        //
        // ```ignore
        // let resp = self.http
        //     .post(format!("{}/v1/audio/speech", self.endpoint))
        //     .json(&serde_json::json!({
        //         "model": "kokoro",
        //         "input": text,
        //         "voice": self.voice,
        //         "response_format": "pcm",
        //         "stream": true,
        //     }))
        //     .send()
        //     .await?;
        //
        // let mut stream = resp.bytes_stream();
        // while let Some(chunk) = stream.next().await {
        //     if cancel.is_cancelled() { break; }
        //     let bytes = chunk?;
        //     // Kokoro outputs 16-bit mono PCM at 24 kHz.
        //     let samples = pcm_to_i16(&bytes);
        //     let resampled = resample_24k_to_output(&samples);
        //     tts_queue.push(&resampled);
        // }
        // ```
        let _ = (text, tts_queue, cancel);
        anyhow::bail!(
            "Kokoro TTS plugin is not yet implemented — \
             complete the HTTP streaming call in src/tts/kokoro.rs"
        );
    }
}

/// Resample a 24 kHz mono `i16` buffer to [`OUTPUT_SAMPLE_RATE` using linear
/// interpolation. Replace with a windowed-sinc FIR resampler for higher fidelity.
#[allow(dead_code)]
fn resample_24k_to_output(samples: &[i16]) -> Vec<i16> {
    if samples.is_empty() {
        return Vec::new();
    }
    let ratio = OUTPUT_SAMPLE_RATE as f64 / KOKORO_SAMPLE_RATE as f64;
    let out_len = (samples.len() as f64 * ratio).round() as usize;
    let mut out = Vec::with_capacity(out_len);
    for i in 0..out_len {
        let src_pos = i as f64 / ratio;
        let idx = src_pos.floor() as usize;
        let frac = src_pos - idx as f64;
        let a = samples[idx.min(samples.len() - 1)] as f32;
        let b = samples[(idx + 1).min(samples.len() - 1)] as f32;
        out.push((a + (b - a) * frac as f32).round() as i16);
    }
    out
}