//! Tests for DID validation

use atproto_plc::Did;
use serde::Deserialize;

#[derive(Deserialize)]
struct InvalidDidTestCase {
    did: String,
    reason: String,
}

#[test]
fn test_valid_dids() {
    let valid_dids_json = include_str!("fixtures/valid_dids.json");
    let valid_dids: Vec<String> = serde_json::from_str(valid_dids_json).unwrap();

    for did_str in valid_dids {
        let result = Did::parse(&did_str);
        assert!(
            result.is_ok(),
            "Expected {} to be valid, got error: {:?}",
            did_str,
            result.err()
        );

        let did = result.unwrap();
        assert_eq!(did.as_str(), did_str);
        assert!(did.is_valid());
        assert_eq!(did.identifier().len(), 24);
    }
}

#[test]
fn test_invalid_dids() {
    let invalid_dids_json = include_str!("fixtures/invalid_dids.json");
    let invalid_dids: Vec<InvalidDidTestCase> = serde_json::from_str(invalid_dids_json).unwrap();

    for test_case in invalid_dids {
        let result = Did::parse(&test_case.did);
        assert!(
            result.is_err(),
            "Expected {} to be invalid ({}), but it was accepted",
            test_case.did,
            test_case.reason
        );
    }
}

#[test]
fn test_did_display_and_debug() {
    let did = Did::parse("did:plc:ewvi7nxzyoun6zhxrhs64oiz").unwrap();

    // Test Display
    assert_eq!(format!("{}", did), "did:plc:ewvi7nxzyoun6zhxrhs64oiz");

    // Test Debug
    let debug_str = format!("{:?}", did);
    assert!(debug_str.contains("Did"));
}

#[test]
fn test_did_serialization() {
    let did = Did::parse("did:plc:ewvi7nxzyoun6zhxrhs64oiz").unwrap();

    // Serialize to JSON
    let json = serde_json::to_string(&did).unwrap();
    assert_eq!(json, "\"did:plc:ewvi7nxzyoun6zhxrhs64oiz\"");

    // Deserialize from JSON
    let deserialized: Did = serde_json::from_str(&json).unwrap();
    assert_eq!(did, deserialized);
}

#[test]
fn test_did_from_str() {
    use std::str::FromStr;

    let did = Did::from_str("did:plc:ewvi7nxzyoun6zhxrhs64oiz").unwrap();
    assert_eq!(did.identifier(), "ewvi7nxzyoun6zhxrhs64oiz");

    // Invalid should error
    assert!(Did::from_str("invalid").is_err());
}

#[test]
fn test_did_clone_and_equality() {
    let did1 = Did::parse("did:plc:ewvi7nxzyoun6zhxrhs64oiz").unwrap();
    let did2 = did1.clone();

    assert_eq!(did1, did2);
    assert_eq!(did1.as_str(), did2.as_str());
}

#[test]
fn test_did_from_identifier() {
    let did = Did::from_identifier("ewvi7nxzyoun6zhxrhs64oiz").unwrap();
    assert_eq!(did.as_str(), "did:plc:ewvi7nxzyoun6zhxrhs64oiz");
    assert_eq!(did.identifier(), "ewvi7nxzyoun6zhxrhs64oiz");

    // Invalid identifier
    assert!(Did::from_identifier("tooshort").is_err());
    assert!(Did::from_identifier("0189abcdefghijklmnopqrst").is_err());
}