use mxlink::matrix_sdk::ruma::OwnedMxcUri;
use mxlink::matrix_sdk::ruma::events::room::message::{
    FileMessageEventContent, ImageMessageEventContent,
};
use mxlink::mime;

use super::super::ControllerTrait;
use crate::agent::AgentPurpose;
use crate::conversation::llm::{
    Author as LLMAuthor, FileDetails, ImageDetails, Message as LLMMessage,
    MessageContent as LLMMessageContent,
};

use super::config::{Config, VeniceParameters, WebSearchMode};
use super::controller::Controller;
use super::utils::convert_llm_messages_to_venice;
use super::wire::{
    ContentPart, EditImageRequest, GenerateImageRequest, MessageContent, SpeechRequest,
};

#[test]
fn config_round_trips_with_venice_parameters() {
    let yaml = r#"
base_url: https://api.venice.ai/api/v1
api_key: test-key
text_generation:
  model_id: kimi-k2-5
  temperature: 0.7
  max_response_tokens: 1024
  max_context_tokens: 65536
  venice_parameters:
    enable_web_search: "auto"
    enable_web_citations: true
speech_to_text:
  model_id: nvidia/parakeet-tdt-0.6b-v3
"#;

    let config: Config = serde_yaml_ng::from_str(yaml).expect("config should deserialize");

    let tg = config.text_generation.expect("text_generation present");
    let vp = tg.venice_parameters.expect("venice_parameters present");

    assert!(matches!(vp.enable_web_search, Some(WebSearchMode::Auto)));
    assert_eq!(vp.enable_web_citations, Some(true));
    assert_eq!(vp.character_slug, None);

    // The bag must serialize the enum to the exact wire string, and an unset knob must be ABSENT
    // (not `null`) so the strict `additionalProperties: false` body is honored.
    let json = serde_json::to_string(&vp).expect("serialize venice_parameters");
    assert!(
        json.contains("\"enable_web_search\":\"auto\""),
        "web search should be the literal \"auto\": {json}"
    );
    assert!(
        !json.contains("character_slug"),
        "an unset knob must be omitted entirely: {json}"
    );
    assert!(!json.contains("null"), "no nulls belong in the body: {json}");
}

#[test]
fn converts_image_to_data_uri_and_skips_files() {
    let messages = vec![
        LLMMessage {
            author: LLMAuthor::User,
            sender_id: None,
            timestamp: chrono::Utc::now(),
            content: LLMMessageContent::Text("describe this".to_owned()),
        },
        LLMMessage {
            author: LLMAuthor::User,
            sender_id: None,
            timestamp: chrono::Utc::now(),
            content: LLMMessageContent::Image(ImageDetails::new(
                ImageMessageEventContent::plain(
                    "pic.png".to_owned(),
                    OwnedMxcUri::from("mxc://example.com/abc"),
                ),
                mime::IMAGE_PNG,
                vec![1, 2, 3],
            )),
        },
        LLMMessage {
            author: LLMAuthor::User,
            sender_id: None,
            timestamp: chrono::Utc::now(),
            content: LLMMessageContent::File(FileDetails::new(
                FileMessageEventContent::plain(
                    "doc.pdf".to_owned(),
                    OwnedMxcUri::from("mxc://example.com/def"),
                ),
                mime::APPLICATION_PDF,
                vec![4, 5, 6],
            )),
        },
    ];

    let converted = convert_llm_messages_to_venice(messages);

    // Text and image survive; the file is warn-skipped.
    assert_eq!(converted.len(), 2);

    match &converted[0].content {
        MessageContent::Text(text) => assert_eq!(text, "describe this"),
        other => panic!("expected bare text, got {other:?}"),
    }

    match &converted[1].content {
        MessageContent::Parts(parts) => match &parts[0] {
            ContentPart::ImageUrl { image_url } => assert!(
                image_url.url.starts_with("data:image/png;base64,"),
                "image should be inlined as a data URI: {}",
                image_url.url
            ),
        },
        other => panic!("expected image parts, got {other:?}"),
    }
}

#[test]
fn supports_purpose_truth_table() {
    let config: Config = serde_yaml_ng::from_str(
        r#"
base_url: https://api.venice.ai/api/v1
api_key: test-key
text_generation:
  model_id: kimi-k2-5
speech_to_text:
  model_id: nvidia/parakeet-tdt-0.6b-v3
"#,
    )
    .expect("config should deserialize");

    let controller = Controller::new(config);

    assert!(controller.supports_purpose(AgentPurpose::TextGeneration));
    assert!(controller.supports_purpose(AgentPurpose::SpeechToText));
    assert!(controller.supports_purpose(AgentPurpose::CatchAll));
    assert!(!controller.supports_purpose(AgentPurpose::TextToSpeech));
    assert!(!controller.supports_purpose(AgentPurpose::ImageGeneration));
}

#[test]
fn supports_purpose_true_when_image_and_tts_blocks_present() {
    let config: Config = serde_yaml_ng::from_str(
        r#"
base_url: https://api.venice.ai/api/v1
api_key: test-key
text_to_speech:
  model_id: tts-kokoro
image_generation:
  model_id: chroma
"#,
    )
    .expect("config should deserialize");

    let controller = Controller::new(config);

    assert!(controller.supports_purpose(AgentPurpose::TextToSpeech));
    assert!(controller.supports_purpose(AgentPurpose::ImageGeneration));
}

#[test]
fn speech_request_serializes_voice_and_omits_unset() {
    let request = SpeechRequest {
        model: "tts-kokoro".to_owned(),
        input: "hello".to_owned(),
        voice: Some("af_sky".to_owned()),
        speed: None,
        response_format: Some("mp3".to_owned()),
        prompt: None,
        temperature: None,
        top_p: None,
    };

    let json = serde_json::to_string(&request).expect("serialize SpeechRequest");

    assert!(
        json.contains("\"voice\":\"af_sky\""),
        "voice should be present: {json}"
    );
    assert!(
        !json.contains("temperature"),
        "an unset knob must be omitted (not null): {json}"
    );
    assert!(!json.contains("null"), "no nulls belong in the body: {json}");
}

#[test]
fn generate_image_request_pins_flags_and_omits_unset() {
    let request = GenerateImageRequest {
        model: "chroma".to_owned(),
        prompt: "a cat".to_owned(),
        return_binary: false,
        variants: 1,
        negative_prompt: None,
        cfg_scale: None,
        steps: None,
        style_preset: None,
        seed: None,
        safe_mode: None,
        hide_watermark: None,
        format: None,
        width: None,
        height: None,
        aspect_ratio: None,
        resolution: None,
        quality: None,
        lora_strength: None,
        embed_exif_metadata: None,
        enable_web_search: None,
    };

    let json = serde_json::to_string(&request).expect("serialize GenerateImageRequest");

    assert!(json.contains("\"model\":\"chroma\""), "{json}");
    assert!(
        json.contains("\"return_binary\":false"),
        "return_binary must be pinned false: {json}"
    );
    assert!(
        json.contains("\"variants\":1"),
        "variants must be pinned 1: {json}"
    );
    assert!(
        !json.contains("cfg_scale"),
        "an unset knob must be omitted: {json}"
    );
    assert!(!json.contains("null"), "no nulls belong in the body: {json}");
}

#[test]
fn edit_image_request_carries_model_and_base64_image() {
    let request = EditImageRequest {
        model: "firered-image-edit".to_owned(),
        prompt: "make it a sunrise".to_owned(),
        image: "aGVsbG8=".to_owned(),
        output_format: None,
        aspect_ratio: None,
        resolution: None,
        safe_mode: None,
    };

    let json = serde_json::to_string(&request).expect("serialize EditImageRequest");

    assert!(
        json.contains("\"model\":\"firered-image-edit\""),
        "{json}"
    );
    assert!(
        json.contains("\"image\":\"aGVsbG8=\""),
        "the base64 image string must be present: {json}"
    );
    assert!(
        !json.contains("output_format"),
        "an unset knob must be omitted: {json}"
    );
}

#[test]
fn web_search_mode_off_deserializes_from_bare_yaml_off() {
    // `off` is a YAML-1.1 boolean but a plain string under serde_yaml_ng's YAML-1.2 core schema,
    // so it deserializes straight into the lowercase `WebSearchMode::Off`. This pins that the
    // sample config and docs can use the bare, unquoted `off` without it parsing as a boolean.
    let params: VeniceParameters =
        serde_yaml_ng::from_str("enable_web_search: off").expect("bare `off` should deserialize");

    assert!(matches!(params.enable_web_search, Some(WebSearchMode::Off)));
}