use oar_ocr::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Build OCR pipeline with required models
    let ocr = OAROCRBuilder::new(
        "detection_model.onnx",
        "recognition_model.onnx",
        "char_dict.txt",
    )
    .build()?;

    // Process a single image
    let image = load_image("document.jpg")?;
    let results = ocr.predict(vec![image])?;
    let result = &results[0];

    // Print extracted text with confidence scores using the modern TextRegion API
    for text_region in &result.text_regions {
        if let Some((text, confidence)) = text_region.text_with_confidence() {
            println!("Text: {} (confidence: {:.2})", text, confidence);
        }
    }

    // Process multiple images at once
    let images = load_images(&[
        "document1.jpg",
        "document2.jpg",
        "document3.jpg",
    ])?;
    let results = ocr.predict(images)?;

    for result in results {
        println!("Image {}: {} text regions found", result.index, result.text_regions.len());
        for text_region in &result.text_regions {
            if let Some((text, confidence)) = text_region.text_with_confidence() {
                println!("  Text: {} (confidence: {:.2})", text, confidence);
            }
        }
    }

    Ok(())
}

use oar_ocr::oarocr::OAROCRBuilder;

// Basic OCR pipeline
let ocr = OAROCRBuilder::new(
    "models/det.onnx",
    "models/rec.onnx",
    "models/dict.txt"
)
.build()?;

// OCR with optional components
let ocr = OAROCRBuilder::new(
    "models/det.onnx",
    "models/rec.onnx",
    "models/dict.txt"
)
.with_document_image_orientation_classification("models/doc_orient.onnx")
.with_text_line_orientation_classification("models/line_orient.onnx")
.with_document_image_rectification("models/rectify.onnx")
.image_batch_size(4)
.region_batch_size(64)
.build()?;

use oar_ocr::oarocr::OARStructureBuilder;

// Basic layout detection
let structure = OARStructureBuilder::new("models/layout.onnx")
    .build()?;

// Full document structure analysis with table and formula recognition
let structure = OARStructureBuilder::new("models/layout.onnx")
    .with_table_classification("models/table_cls.onnx")
    .with_table_cell_detection("models/table_cell.onnx", "wired")
    .with_table_structure_recognition("models/table_struct.onnx", "wired")
    .table_structure_dict_path("models/table_structure_dict_ch.txt")
    .with_formula_recognition("models/formula.onnx", "models/tokenizer.json", "pp_formulanet")
    .build()?;

// Structure analysis with integrated OCR
let structure = OARStructureBuilder::new("models/layout.onnx")
    .with_table_classification("models/table_cls.onnx")
    .with_ocr("models/det.onnx", "models/rec.onnx", "models/dict.txt")
    .build()?;

use oar_ocr::prelude::*;
use oar_ocr::core::config::{OrtSessionConfig, OrtExecutionProvider};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Configure CUDA execution provider for GPU acceleration
    let ort_config = OrtSessionConfig::new()
        .with_execution_providers(vec![
            OrtExecutionProvider::CUDA {
                device_id: Some(0),  // Use GPU 0
                gpu_mem_limit: None,
                arena_extend_strategy: None,
                cudnn_conv_algo_search: None,
                do_copy_in_default_stream: None,
                cudnn_conv_use_max_workspace: None,
            },
            OrtExecutionProvider::CPU,  // Fallback to CPU if CUDA fails
        ]);

    // Build OCR pipeline with CUDA support
    let ocr = OAROCRBuilder::new(
        "detection_model.onnx",
        "recognition_model.onnx",
        "char_dict.txt",
    )
    .ort_session(ort_config)  // Apply ORT config to all components
    .build()?;

    // Process images (same as CPU example)
    let image = load_image("document.jpg")?;
    let results = ocr.predict(vec![image])?;
    let result = &results[0];

    // Extract text from results
    for text_region in &result.text_regions {
        if let Some((text, confidence)) = text_region.text_with_confidence() {
            println!("Text: {} (confidence: {:.2})", text, confidence);
        }
    }

    Ok(())
}