//! TDD tests for architecture module imports
//! These tests define expected behavior for importing vision architecture types

use rtx_vision::architectures::{
    mobilenet::{DepthwiseSeparableConv, InvertedResidual, MobileNetConfig, MobileNetVariant},
    mobilevit::{
        EfficientAttention, EfficientAttentionConfig, MobileViTBlock, MobileViTBlockConfig,
        MobileViTConfig, MobileViTVariant, TransformerBlock,
    },
    nfnet::{
        AGCConfig, AdaptiveGradientClipping, NFBlock, NFBlockConfig, NFNetConfig, NFNetHead,
        NFNetStem, NFNetTransition, NFNetVariant, ScaledWSConfig, ScaledWeightStandardization,
    },
    regnet::{
        RegNetBlock, RegNetBlockConfig, RegNetConfig, RegNetHead, RegNetStage, RegNetStageConfig,
        RegNetStem, SEModule, SEModuleConfig,
    },
};

#[test]
fn test_mobilenet_types_exist() {
    // Test that MobileNet types are properly exported and instantiable
    let config = MobileNetConfig::default();
    assert!(matches!(
        config.variant,
        MobileNetVariant::V1
            | MobileNetVariant::V2
            | MobileNetVariant::V3Small
            | MobileNetVariant::V3Large
    ));

    // Test that key components can be created
    let _conv = DepthwiseSeparableConv::new(32, 64, 3, 1, 1);
    let _residual = InvertedResidual::new(32, 64, 3, 1, 6);
}

#[test]
fn test_mobilevit_types_exist() {
    // Test that MobileViT types are properly exported and instantiable
    let config = MobileViTConfig::default();
    assert!(matches!(
        config.variant,
        MobileViTVariant::XS | MobileViTVariant::S | MobileViTVariant::XXS
    ));

    // Test that key components can be created
    let block_config = MobileViTBlockConfig::new(128, 256, 4);
    let _block = MobileViTBlock::new(block_config);

    let attn_config = EfficientAttentionConfig::new(256, 8);
    let _attention = EfficientAttention::new(attn_config);

    let _transformer = TransformerBlock::new(256, 8, 1024);
}

#[test]
fn test_nfnet_types_exist() {
    // Test that NFNet types are properly exported and instantiable
    let config = NFNetConfig::default();
    assert!(matches!(
        config.variant,
        NFNetVariant::F0 | NFNetVariant::F1 | NFNetVariant::F2
    ));

    // Test that key components can be created
    let block_config = NFBlockConfig::new(256, 1024, 1, 1);
    let _block = NFBlock::new(block_config);

    let _stem = NFNetStem::new(64);
    let _transition = NFNetTransition::new(256, 512);
    let _head = NFNetHead::new(2048, 1000);

    let agc_config = AGCConfig::new(0.01);
    let _agc = AdaptiveGradientClipping::new(agc_config);

    let ws_config = ScaledWSConfig::new(1.0);
    let _sws = ScaledWeightStandardization::new(ws_config);
}

#[test]
fn test_regnet_types_exist() {
    // Test that RegNet types are properly exported and instantiable
    let config = RegNetConfig::default();
    assert!(config.depth > 0);
    assert!(config.width > 0);

    // Test that key components can be created
    let block_config = RegNetBlockConfig::new(256, 256, 1, 1);
    let _block = RegNetBlock::new(block_config);

    let stage_config = RegNetStageConfig::new(256, 512, 2, 1);
    let _stage = RegNetStage::new(stage_config);

    let _stem = RegNetStem::new(64);
    let _head = RegNetHead::new(2048, 1000);

    let se_config = SEModuleConfig::new(256, 16);
    let _se = SEModule::new(se_config);
}

#[test]
fn test_architecture_integration() {
    // Test that architectures can be used together and have consistent interfaces
    let mobilenet_config = MobileNetConfig::default();
    let mobilevit_config = MobileViTConfig::default();
    let nfnet_config = NFNetConfig::default();
    let regnet_config = RegNetConfig::default();

    // All configs should have basic properties
    assert!(mobilenet_config.num_classes > 0);
    assert!(mobilevit_config.num_classes > 0);
    assert!(nfnet_config.num_classes > 0);
    assert!(regnet_config.num_classes > 0);
}

#[test]
fn test_default_configurations() {
    // Test that default configurations are reasonable
    let mobilenet = MobileNetConfig::default();
    assert_eq!(mobilenet.num_classes, 1000);
    assert_eq!(mobilenet.width_multiplier, 1.0);

    let mobilevit = MobileViTConfig::default();
    assert_eq!(mobilevit.num_classes, 1000);
    assert_eq!(mobilevit.image_size, 256);

    let nfnet = NFNetConfig::default();
    assert_eq!(nfnet.num_classes, 1000);
    assert!(nfnet.alpha > 0.0);

    let regnet = RegNetConfig::default();
    assert_eq!(regnet.num_classes, 1000);
    assert!(regnet.stem_width > 0);
}