use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers};
use owlen_core::provider::{GenerateChunk, GenerateRequest, ProviderStatus};
use owlen_tui::app::messages::AppMessage;
use uuid::Uuid;

#[test]
fn message_variants_roundtrip_their_data() {
    let request = GenerateRequest::new("demo-model");
    let request_id = Uuid::new_v4();
    let key_event = KeyEvent {
        code: KeyCode::Char('a'),
        modifiers: KeyModifiers::CONTROL,
        kind: KeyEventKind::Press,
        state: KeyEventState::NONE,
    };

    let messages = vec![
        AppMessage::KeyPress(key_event),
        AppMessage::Resize {
            width: 120,
            height: 40,
        },
        AppMessage::Tick,
        AppMessage::GenerateStart {
            request_id,
            provider_id: "mock".into(),
            request: request.clone(),
        },
        AppMessage::GenerateChunk {
            request_id,
            chunk: GenerateChunk::from_text("hi"),
        },
        AppMessage::GenerateComplete { request_id },
        AppMessage::GenerateError {
            request_id: Some(request_id),
            message: "oops".into(),
        },
        AppMessage::ModelsRefresh,
        AppMessage::ModelsUpdated,
        AppMessage::ProviderStatus {
            provider_id: "mock".into(),
            status: ProviderStatus::Available,
        },
    ];

    for message in messages {
        match message {
            AppMessage::KeyPress(event) => {
                assert_eq!(event.code, KeyCode::Char('a'));
                assert!(event.modifiers.contains(KeyModifiers::CONTROL));
            }
            AppMessage::Resize { width, height } => {
                assert_eq!(width, 120);
                assert_eq!(height, 40);
            }
            AppMessage::Tick => {}
            AppMessage::GenerateStart {
                request_id: id,
                provider_id,
                request,
            } => {
                assert_eq!(id, request_id);
                assert_eq!(provider_id, "mock");
                assert_eq!(request.model, "demo-model");
            }
            AppMessage::GenerateChunk {
                request_id: id,
                chunk,
            } => {
                assert_eq!(id, request_id);
                assert_eq!(chunk.text.as_deref(), Some("hi"));
            }
            AppMessage::GenerateComplete { request_id: id } => {
                assert_eq!(id, request_id);
            }
            AppMessage::GenerateError {
                request_id: Some(id),
                message,
            } => {
                assert_eq!(id, request_id);
                assert_eq!(message, "oops");
            }
            AppMessage::ModelsRefresh => {}
            AppMessage::ModelsUpdated => {}
            AppMessage::ProviderStatus {
                provider_id,
                status,
            } => {
                assert_eq!(provider_id, "mock");
                assert!(matches!(status, ProviderStatus::Available));
            }
            AppMessage::GenerateError {
                request_id: None, ..
            } => panic!("missing request id"),
        }
    }
}