//! Multi-Service Demo
//!
//! Shows how multiple services can run on the same mesh router.

use meshservice::{
    capabilities,
    identity::ServiceIdentity,
    router::ServiceRouter,
    service_ids,
    services::{
        fapp::{create_announce as fapp_announce, FappService, Modality, SlotAnnounce, Specialism},
        housing::{
            amenities, create_announce as housing_announce, HousingService, ListingAnnounce,
            ListingType,
        },
    },
    verification::{TrustedVerifiers, Verification, VerificationLevel},
};

fn main() {
    println!("=== Multi-Service Mesh Demo ===\n");

    // Create a router that handles both FAPP and Housing
    let mut router = ServiceRouter::new(capabilities::RELAY | capabilities::CONSUMER);
    router.register(Box::new(FappService::relay()));
    router.register(Box::new(HousingService::relay()));

    println!("Registered services:");
    for (id, name) in router.services() {
        println!("  0x{:04x} - {}", id, name);
    }
    println!();

    // Create identities
    let therapist = ServiceIdentity::generate();
    let landlord = ServiceIdentity::generate();
    let registry = ServiceIdentity::generate();

    // Setup trusted verifiers
    let mut verifiers = TrustedVerifiers::new();
    verifiers.add(
        registry.public_key(),
        "Health Registry",
        VerificationLevel::RegistryVerified,
    );
    router.set_trusted_verifiers(verifiers);

    // Therapist announcement with verification
    println!("--- Adding FAPP announcement ---");
    let fapp_data = SlotAnnounce::new(&[Specialism::Psychoanalysis], Modality::InPerson, "104")
        .with_profile("https://kbv.de/therapists/12345");

    let mut fapp_msg = fapp_announce(&therapist, &fapp_data, 1).unwrap();

    // Registry verifies therapist
    let verification = Verification::registry(
        &registry,
        &therapist.address(),
        "licensed_therapist",
        "KBV-12345",
    );
    fapp_msg.add_verification(verification);

    router.handle(fapp_msg, Some(therapist.public_key())).unwrap();
    println!("FAPP announcement stored (with registry verification)\n");

    // Housing announcement
    println!("--- Adding Housing announcement ---");
    let housing_data = ListingAnnounce::new(ListingType::Studio, 35, 700, "104")
        .with_amenities(amenities::FURNISHED | amenities::INTERNET)
        .with_title("Cozy studio near therapist offices");

    let housing_msg = housing_announce(&landlord, &housing_data, 1).unwrap();
    router.handle(housing_msg, Some(landlord.public_key())).unwrap();
    println!("Housing announcement stored\n");

    // Summary
    println!("--- Store Summary ---");
    println!("FAPP messages:    {}", router.store().service_count(service_ids::FAPP));
    println!("Housing messages: {}", router.store().service_count(service_ids::HOUSING));
    println!("Total messages:   {}", router.store().len());

    println!("\n=== Multi-Service Demo Complete ===");
    println!("\nThe mesh can route and store messages for multiple services");
    println!("using a single router instance. Each service has its own:");
    println!("  - Payload format");
    println!("  - Query matching logic");
    println!("  - Handler implementation");
}