import os
import sys

sys.path.append(os.path.dirname(os.path.dirname(__file__)))

import numpy as np
from src.models import WaterSoundData
from src.bridges import PythonBridge
from src.scheduler import CoreScheduler

def test_integration():
    print("Starting integration test...")
    
    # 1. Prepare Data
    raw = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
    wsd = WaterSoundData(raw_data=raw, sample_rate=100.0)
    
    # 2. Define Algos
    def mock_clean(raw_data):
        return raw_data * 2.0
        
    def mock_feat(clean_data):
        return np.mean(clean_data)
        
    # 3. Create Bridges
    clean_bridge = PythonBridge("Clean", mock_clean, 
                                 {"raw_data": "raw_data"}, {"0": "clean_data"})
    feat_bridge = PythonBridge("Feature", mock_feat, 
                                {"clean_data": "clean_data"}, {"0": "feat_data"})
                                
    # 4. Schedule
    scheduler = CoreScheduler()
    scheduler.set_flow([clean_bridge, feat_bridge])
    
    # 5. Execute
    final_wsd = scheduler.execute(wsd)
    
    # 6. Verify
    print(f"Status: {final_wsd.status}")
    print(f"Log length: {len(final_wsd.log)}")
    print(f"Clean data: {final_wsd.clean_data}")
    print(f"Feat data: {final_wsd.feat_data}")
    
    assert final_wsd.status == "finished"
    assert np.array_equal(final_wsd.clean_data, raw * 2.0)
    assert final_wsd.feat_data == np.mean(raw * 2.0)
    
    print("Integration test passed!")

def test_validation():
    print("Starting validation test...")
    from src.validator import FlowValidator
    
    # 1. Test Field Existence
    wsd = WaterSoundData()
    exists, msg, sug = FlowValidator.check_field_existence(wsd, "raw_data")
    assert not exists
    assert "缺少必要字段" in msg
    print("Field existence check passed.")
    
    # 2. Test Data Type
    wsd.raw_data = "not a numpy array"
    valid, msg, sug = FlowValidator.check_data_type(wsd, "raw_data", "ndarray")
    assert not valid
    assert "类型不匹配" in msg
    print("Data type check passed.")
    
    # 3. Test Dimensions
    wsd.raw_data = np.zeros((10, 10))
    valid, msg, sug = FlowValidator.check_dimensions(wsd, "raw_data", [10]) # Expected 1D, got 2D
    assert not valid
    assert "维度不匹配" in msg
    print("Dimension check passed.")
    
    # 4. Test Scheduler validation
    def mock_clean(raw_data): return raw_data
    bridge = PythonBridge("Clean", mock_clean, {"raw_data": "raw_data"}, {"0": "clean_data"})
    scheduler = CoreScheduler()
    scheduler.set_flow([bridge])
    
    empty_wsd = WaterSoundData()
    issues = scheduler.validate_flow(empty_wsd)
    assert len(issues) == 1
    assert issues[0]['algo'] == "Clean"
    print("Scheduler validation flow passed.")

def test_sea_trial_pipeline():
    print("Starting sea-trial pipeline test...")
    from src.sample_algorithms import dc_removal_and_bandpass, quality_check, snr_estimation

    # Use a simple synthetic signal (length > filtfilt padlen)
    t = np.linspace(0, 1.0, 2000, endpoint=False)
    raw = (0.5 * np.sin(2 * np.pi * 50 * t) + 0.05 * np.random.randn(t.size)).astype(float)
    wsd = WaterSoundData(raw_data=raw, sample_rate=1000.0)

    b1 = PythonBridge("去直流+带通", dc_removal_and_bandpass,
                      {"raw_data": "raw_data", "fs": "sample_rate"}, {"0": "clean_data"})
    b2 = PythonBridge("质量巡检", quality_check,
                      {"raw_data": "raw_data"}, {"0": "core_index"})
    b3 = PythonBridge("SNR估计", snr_estimation,
                      {"raw_data": "clean_data"}, {"0": "snr_value"})

    scheduler = CoreScheduler()
    scheduler.set_flow([b1, b2, b3])
    result = scheduler.execute(wsd)

    assert result.status == "finished"
    assert isinstance(result.core_index, dict)
    assert "quality_score" in result.core_index
    assert hasattr(result, "snr_value")
    print("Sea-trial pipeline test passed.")

def test_cpp_bridge():
    print("Starting C++ bridge test...")
    from src.bridges import CppBridge
    
    lib_path = "src/sample_algos_cpp/simple_ops.so"
    if not os.path.exists(lib_path):
        print("C++ library not found, skipping CPP test.")
        return

    raw = np.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype=np.float64)
    wsd = WaterSoundData(clean_data=raw)
    
    cpp_bridge = CppBridge(
        "GainCPP",
        lib_path,
        "multiply_by_factor_cpp",
        {"in_data": "clean_data"},
        {"0": "final_result"}
    )
    
    scheduler = CoreScheduler()
    scheduler.set_flow([cpp_bridge])
    result = scheduler.execute(wsd)
    
    if result.status != "finished":
        print(f"C++ Bridge Execution Failed: {result.error_info}")
        for l in result.log:
            print(f"  Log: {l}")
    
    assert result.status == "finished"
    assert np.allclose(result.final_result, raw * 1.5)
    print("C++ bridge test passed.")

def test_matlab_bridge_fallback():
    print("Starting MATLAB bridge fallback test...")
    from src.bridges import MatlabBridge
    
    # 我们知道当前环境没有 MATLAB/Octave，所以预期它会抛出 RuntimeError
    m_bridge = MatlabBridge(
        "FilterM",
        "src/sample_algos_matlab",
        "bandpass_filter_m",
        {"in_data": "raw_data", "fs": "sample_rate"},
        {"0": "clean_data"}
    )
    
    wsd = WaterSoundData(raw_data=np.array([1, 2, 3]), sample_rate=1000.0)
    scheduler = CoreScheduler()
    scheduler.set_flow([m_bridge])
    result = scheduler.execute(wsd)
    
    # 预期失败并记录错误
    assert result.status == "error"
    assert "No MATLAB/Octave environment found" in result.error_info
    print("MATLAB bridge fallback test passed (caught expected error).")

if __name__ == "__main__":
    test_integration()
    test_validation()
    test_sea_trial_pipeline()
    test_cpp_bridge()
    test_matlab_bridge_fallback()