//! End-to-end demo: drives the real `rtx-inference` engine through `RealInferenceEngine`
//! for a couple of `ModelCategory` variants and prints the resulting
//! `InferenceResult` (real measured latency, real device, real-compute-backed output).

use model_zoo_shared::{InferenceRequest, ModelCategory};
use rtx_model_zoo::RealInferenceEngine;

fn main() {
    println!("Building RealInferenceEngine (loads a tiny real transformer)...");
    let engine = RealInferenceEngine::new().expect("failed to build RealInferenceEngine");
    println!("Engine ready.\n");

    match engine.model_info() {
        Ok(info) => {
            println!("Real loaded model metadata (from the real rtx-inference engine):");
            println!("  name:             {}", info.name);
            println!("  parameter_count:  {}", info.parameter_count);
            println!("  memory_usage:     {} bytes", info.memory_usage);
            println!("  layer_count:      {}", info.layer_count);
            println!();
        }
        Err(e) => println!("model_info() failed: {e}\n"),
    }

    let cases = [
        (
            "gpt2_small",
            "Machine learning",
            "text/plain",
            ModelCategory::TextGeneration,
        ),
        (
            "resnet50",
            "base64encodedimage",
            "image/jpeg",
            ModelCategory::ImageClassification,
        ),
        (
            "yolov8n",
            "base64encodedimage",
            "image/jpeg",
            ModelCategory::ObjectDetection,
        ),
        (
            "bert_base_uncased",
            "This is a great product",
            "text/plain",
            ModelCategory::NLP,
        ),
    ];

    for (model_id, input_data, input_type, category) in cases {
        let request = InferenceRequest {
            model_id: model_id.to_string(),
            input_data: input_data.to_string(),
            input_type: input_type.to_string(),
        };
        println!("category: {category:?}");
        match engine.run_inference(&request, category) {
            Ok(result) => {
                println!("  model_id:          {}", result.model_id);
                println!("  device:            {}", result.device);
                println!("  inference_time_ms: {:.4}", result.inference_time_ms);
                println!("  output:            {}", result.output);
            }
            Err(e) => {
                println!("  real engine attempt failed (see module docs for known upstream bug):");
                println!("  {e}");
            }
        }
        println!();
    }
}