#!/usr/bin/env python3
"""
Test the new features added to Python bindings
"""

import sys

sys.path.insert(0, ".")


def test_meta_learning_configurable_min_points():
    """Test that min_data_points is now configurable."""
    print("Testing MetaLearningAnalyzer configurable min_data_points...")

    import alfars as ae

    # Create analyzer
    analyzer = ae.MetaLearningAnalyzer()

    # Check default value
    default_min = analyzer.get_min_data_points()
    print(f"  Default min_data_points: {default_min}")

    # Change the value
    analyzer.set_min_data_points(10)
    new_min = analyzer.get_min_data_points()
    print(f"  New min_data_points: {new_min}")

    # Verify change
    if new_min == 10:
        print("  ✓ min_data_points successfully configured")
        return True
    else:
        print(f"  ✗ min_data_points not changed: {new_min}")
        return False


def test_gp_recommendations_enhancements():
    """Test GPRecommendations enhancements."""
    print("\nTesting GPRecommendations enhancements...")

    import alfars as ae

    # Create a dummy analyzer to get recommendations
    analyzer = ae.MetaLearningAnalyzer()

    # Get recommendations (empty since not trained)
    recommendations = analyzer.get_recommendations()

    # Test existing properties
    print(f"  Recommended functions: {recommendations.recommended_functions}")
    print(f"  Recommended terminals: {recommendations.recommended_terminals}")
    print(f"  Target complexity: {recommendations.target_complexity}")
    print(f"  Confidence score: {recommendations.confidence_score}")
    print(f"  Confidence level: {recommendations.confidence_level}")
    print(f"  Is valid: {recommendations.is_valid()}")

    # Test to_gp_config method
    try:
        config_dict = recommendations.to_gp_config()
        print(f"  GP config dict: {dict(config_dict)}")
        print("  ✓ to_gp_config() works")
        return True
    except Exception as e:
        print(f"  ✗ to_gp_config() failed: {e}")
        return False


def test_comprehensive_workflow():
    """Test a more comprehensive workflow."""
    print("\nTesting comprehensive workflow...")

    import alfars as ae
    import numpy as np
    import tempfile
    import shutil

    try:
        # 1. Create test data
        n_days = 20
        n_assets = 10
        data = {
            "close": np.random.randn(n_days, n_assets),
            "open": np.random.randn(n_days, n_assets),
            "volume": np.random.randn(n_days, n_assets),
        }
        returns = np.random.randn(n_days, n_assets)

        print(f"  Created test data: {n_days} days × {n_assets} assets")

        # 2. Create GP engine
        gp = ae.GpEngine(
            population_size=30,
            max_generations=5,
            tournament_size=3,
            crossover_prob=0.8,
            mutation_prob=0.2,
            max_depth=4,
        )

        # Set columns
        gp.set_columns(["close", "open", "volume"])
        print("  ✓ Created and configured GpEngine")

        # 3. Run GP (small scale for testing)
        try:
            factors = gp.mine_factors(data, returns, num_factors=2)
            print(f"  ✓ Mined {len(factors)} factors")
            for i, (expr, fitness) in enumerate(factors):
                print(f"    Factor {i + 1}: {expr[:50]}... (fitness: {fitness:.4f})")
        except Exception as e:
            print(f"  ⚠ GP mining test skipped or failed: {e}")
            # This might fail due to data quality, which is okay for test

        # 4. Test PersistenceManager
        temp_dir = tempfile.mkdtemp()
        pm = ae.PersistenceManager(temp_dir)
        print(f"  ✓ Created PersistenceManager at {temp_dir}")

        # Test search with various parameters
        results = pm.search_factors(min_ic=0.1, max_complexity=10.0, tags=["test"])
        print(f"  ✓ search_factors() works (found {len(results)} factors)")

        # Test cache stats
        try:
            stats = pm.cache_stats()
            print(f"  ✓ cache_stats() works: {dict(stats)}")
        except Exception as e:
            print(f"  ⚠ cache_stats() failed: {e}")

        shutil.rmtree(temp_dir)

        # 5. Test MetaLearningAnalyzer with configurable settings
        analyzer = ae.MetaLearningAnalyzer()
        analyzer.set_min_data_points(5)  # Lower for testing
        analyzer.set_high_perf_threshold(0.05)  # Lower threshold

        print(
            f"  ✓ Configured analyzer: min_data_points={analyzer.get_min_data_points()}, "
            f"threshold={analyzer.get_high_perf_threshold()}"
        )

        print("  ✓ Comprehensive workflow test completed")
        return True

    except Exception as e:
        print(f"  ✗ Comprehensive workflow failed: {e}")
        import traceback

        traceback.print_exc()
        return False


def main():
    """Run all new feature tests."""
    print("ALPHA-EXPR v0.2.0 NEW FEATURES TEST")
    print("=" * 80)

    tests = [
        ("Configurable min_data_points", test_meta_learning_configurable_min_points),
        ("GPRecommendations enhancements", test_gp_recommendations_enhancements),
        ("Comprehensive workflow", test_comprehensive_workflow),
    ]

    passed = 0
    total = len(tests)

    for test_name, test_func in tests:
        try:
            success = test_func()
            if success:
                print(f"✓ {test_name} PASSED\n")
                passed += 1
            else:
                print(f"✗ {test_name} FAILED\n")
        except Exception as e:
            print(f"✗ {test_name} ERROR: {e}\n")
            import traceback

            traceback.print_exc()

    print("=" * 80)
    print(f"SUMMARY: {passed}/{total} tests passed")

    if passed == total:
        print("\n🎉 ALL NEW FEATURES WORK CORRECTLY!")
        print("Python bindings are now more flexible and user-friendly.")
    else:
        print(f"\n⚠️ {total - passed} tests failed.")

    return 0 if passed == total else 1


if __name__ == "__main__":
    sys.exit(main())
