import pytest
pytest.skip("Obsolete test file replaced by component-specific unit tests", allow_module_level=True)

from unittest.mock import Mock, MagicMock
from f02_1_flight_lifecycle_manager import FlightLifecycleManager, Flight, GPSPoint, CameraParameters, Waypoint

@pytest.fixture
def mock_deps():
    return {
        "flight_database": Mock(),
        "satellite_data_manager": Mock(),
        "coordinate_transformer": Mock()
    }

@pytest.fixture
def manager(mock_deps):
    return FlightLifecycleManager(mock_deps)

@pytest.fixture
def flight_data():
    return {
        "flight_name": "Test Mission 01",
        "start_gps": {"lat": 48.1, "lon": 37.1},
        "altitude_m": 400.0,
        "camera_params": {"focal_length_mm": 25.0, "sensor_width_mm": 36.0, "resolution": {"width": 640, "height": 480}},
        "geofences": {"polygons": []}
    }

class TestFlightWaypointManagement:

    def test_create_flight_valid_data(self, manager, mock_deps, flight_data):
        flight_id = manager.create_flight(flight_data)
        assert flight_id is not None
        assert isinstance(flight_id, str)
        
        # Verify dependencies were called
        mock_deps["flight_database"].insert_flight.assert_called_once()
        mock_deps["coordinate_transformer"].set_enu_origin.assert_called_once()
        mock_deps["satellite_data_manager"].prefetch_route_corridor.assert_called_once()

    def test_create_flight_invalid_geofence(self, manager, flight_data):
        # Add an invalid geofence structure
        flight_data["geofences"] = Mock(polygons=[Mock(north_west=None)])
        
        with pytest.raises(ValueError, match="Invalid geofence"):
            manager.create_flight(flight_data)

    def test_get_flight_returns_none_if_missing(self, manager, mock_deps):
        mock_deps["flight_database"].get_flight_by_id.return_value = None
        flight = manager.get_flight("missing_id")
        assert flight is None

    def test_delete_flight_removes_from_db(self, manager, mock_deps):
        manager.delete_flight("test_flight_1")
        mock_deps["flight_database"].delete_flight.assert_called_with("test_flight_1")
        # Should also clear cache
        mock_deps["satellite_data_manager"].clear_flight_cache.assert_called_with("test_flight_1")

    def test_update_flight_status(self, manager, mock_deps):
        mock_flight = Mock()
        mock_deps["flight_database"].get_flight_by_id.return_value = mock_flight
        
        success = manager.update_flight_status("test_flight_1", "processing")
        assert success is True
        assert mock_flight.state == "processing"
        mock_deps["flight_database"].update_flight.assert_called_once_with(mock_flight)

    def test_validate_waypoint(self, manager):
        # Valid
        wp_valid = Waypoint(waypoint_id="1", gps=GPSPoint(lat=45.0, lon=30.0), sequence=1)
        assert manager.validate_waypoint(wp_valid).valid is True
        
        # Invalid Lat
        wp_invalid = Waypoint(waypoint_id="2", gps=GPSPoint(lat=95.0, lon=30.0), sequence=2)
        res = manager.validate_waypoint(wp_invalid)
        assert res.valid is False
        assert "out of bounds" in res.reason

    def test_validate_geofence(self, manager):
        # Empty valid
        assert manager.validate_geofence(Mock(polygons=[])).valid is True
        
        # Invalid polygon (missing corners)
        res = manager.validate_geofence(Mock(polygons=[Mock(north_west=None, south_east=None)]))
        assert res.valid is False
        assert "Invalid polygon" in res.reason

    def test_validate_flight_continuity(self, manager):
        # Placeholder logic currently returns True
        res = manager.validate_flight_continuity([])
        assert res.valid is True

    def test_waypoint_update_validates_first(self, manager, mock_deps):
        wp_invalid = Waypoint(waypoint_id="1", gps=GPSPoint(lat=100.0, lon=0.0), sequence=1)
        success = manager.update_waypoint("flight_1", "1", wp_invalid)
        assert success is False
        mock_deps["flight_database"].update_waypoint.assert_not_called()
        
        wp_valid = Waypoint(waypoint_id="1", gps=GPSPoint(lat=48.0, lon=37.0), sequence=1)
        manager.update_waypoint("flight_1", "1", wp_valid)
        mock_deps["flight_database"].update_waypoint.assert_called_once()

    def test_batch_update_waypoints(self, manager, mock_deps):
        wp_valid = Waypoint(waypoint_id="1", gps=GPSPoint(lat=48.0, lon=37.0), sequence=1)
        
        mock_batch_result = Mock(updated_count=1, failed_ids=[])
        mock_deps["flight_database"].batch_update_waypoints.return_value = mock_batch_result
        
        res = manager.batch_update_waypoints("flight_1", [wp_valid])
        assert res == mock_batch_result
        mock_deps["flight_database"].batch_update_waypoints.assert_called_once()