"""
End-to-end evaluation tests for design_api.py.

Tests the full pipeline: GeoJSON Input → Parse → Valve Placement → Drip Layout → GeoJSON Output.
Validates structure, crop propagation, valve strategy, BOM accuracy, and design quality metrics.
"""

import json
import math
import pytest
from pathlib import Path

from design_api import process_farm_design, DesignAPIError


# ──────────────────────────────────────────────────────────────────────
# Fixtures — reusable GeoJSON inputs
# ──────────────────────────────────────────────────────────────────────

def _make_feature_collection(features, properties=None):
    """Build a minimal GeoJSON FeatureCollection dict."""
    fc = {"type": "FeatureCollection", "features": features}
    if properties:
        fc["properties"] = properties
    return fc


def _make_polygon_feature(coords, props):
    """Build a GeoJSON Polygon Feature."""
    return {
        "type": "Feature",
        "properties": props,
        "geometry": {
            "type": "Polygon",
            "coordinates": [coords],
        },
    }


def _make_point_feature(lon, lat, props):
    """Build a GeoJSON Point Feature."""
    return {
        "type": "Feature",
        "properties": props,
        "geometry": {
            "type": "Point",
            "coordinates": [lon, lat],
        },
    }


# ~155m × 155m rectangle near Bangalore (~2.4 ha)
FARM_BOUNDARY_COORDS = [
    [77.5946, 12.9716],
    [77.5960, 12.9716],
    [77.5960, 12.9730],
    [77.5946, 12.9730],
    [77.5946, 12.9716],
]

PUMP_LON, PUMP_LAT = 77.5946, 12.9716


@pytest.fixture
def single_crop_input():
    """Single tomato crop covering the full farm."""
    features = [
        _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "farm_boundary"}),
        _make_point_feature(PUMP_LON, PUMP_LAT, {"type": "pump", "pump_hp": 5.0}),
        _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "crop_zone", "crop": "tomato"}),
    ]
    return _make_feature_collection(features, {"pump_hp": 5.0, "headland_buffer_m": 1.0})


@pytest.fixture
def multi_crop_input():
    """Two crop zones: tomato (west half) and lettuce (east half)."""
    west_coords = [
        [77.5946, 12.9716],
        [77.5953, 12.9716],
        [77.5953, 12.9730],
        [77.5946, 12.9730],
        [77.5946, 12.9716],
    ]
    east_coords = [
        [77.5953, 12.9716],
        [77.5960, 12.9716],
        [77.5960, 12.9730],
        [77.5953, 12.9730],
        [77.5953, 12.9716],
    ]
    features = [
        _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "farm_boundary"}),
        _make_point_feature(PUMP_LON, PUMP_LAT, {"type": "pump", "pump_hp": 5.0}),
        _make_polygon_feature(west_coords, {"type": "crop_zone", "crop": "tomato"}),
        _make_polygon_feature(east_coords, {"type": "crop_zone", "crop": "lettuce"}),
    ]
    return _make_feature_collection(features, {"pump_hp": 5.0, "headland_buffer_m": 1.0})


@pytest.fixture
def elevation_input():
    """Farm with significant elevation delta (>5m threshold)."""
    features = [
        _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "farm_boundary"}),
        _make_point_feature(PUMP_LON, PUMP_LAT, {"type": "pump", "pump_hp": 5.0}),
        _make_point_feature(77.5953, 12.9723, {
            "type": "elevation",
            "min_elevation_m": 900,
            "max_elevation_m": 910,
        }),
    ]
    return _make_feature_collection(features, {"pump_hp": 5.0})


# ──────────────────────────────────────────────────────────────────────
# Helpers
# ──────────────────────────────────────────────────────────────────────

def _features_by_type(result, feature_type):
    """Filter output features by properties.type."""
    return [f for f in result.get("features", []) if f["properties"].get("type") == feature_type]


def _run_pipeline(geojson_input):
    """Run the design pipeline, accepting dict or string."""
    if isinstance(geojson_input, dict):
        geojson_input = json.dumps(geojson_input)
    return process_farm_design(geojson_input)


# ──────────────────────────────────────────────────────────────────────
# Test 1: Round-trip with sample input
# ──────────────────────────────────────────────────────────────────────

class TestRoundTrip:
    """Validate end-to-end pipeline with the project's sample input."""

    def test_sample_input_produces_valid_output(self):
        """samples/input_example.json → valid FeatureCollection with all expected layers."""
        sample_path = Path(__file__).parent / "samples" / "input_example.json"
        if not sample_path.exists():
            pytest.skip("samples/input_example.json not found")

        result = _run_pipeline(sample_path.read_text())

        assert result["type"] == "FeatureCollection"
        assert "properties" in result
        assert result["properties"]["type"] == "farm_design"

    def test_output_has_required_layers(self):
        """Output must contain farm_boundary, valve, valve_zone, main_line, lateral features."""
        sample_path = Path(__file__).parent / "samples" / "input_example.json"
        if not sample_path.exists():
            pytest.skip("samples/input_example.json not found")

        result = _run_pipeline(sample_path.read_text())
        feature_types = {f["properties"].get("type") for f in result["features"]}

        assert "farm_boundary" in feature_types
        assert "valve" in feature_types
        assert "valve_zone" in feature_types
        assert "main_line" in feature_types
        assert "lateral" in feature_types

    def test_output_has_bom(self):
        """Output properties must include BOM with cost fields."""
        sample_path = Path(__file__).parent / "samples" / "input_example.json"
        if not sample_path.exists():
            pytest.skip("samples/input_example.json not found")

        result = _run_pipeline(sample_path.read_text())
        bom = result["properties"]["bom"]

        assert "main_line_16mm_m" in bom
        assert "drip_tape_16mm_m" in bom
        assert "inline_emitters" in bom
        assert "valves_count" in bom
        assert bom["valves_count"] >= 1

    def test_output_has_design_summary(self):
        """Output properties must include design_summary with key metrics."""
        sample_path = Path(__file__).parent / "samples" / "input_example.json"
        if not sample_path.exists():
            pytest.skip("samples/input_example.json not found")

        result = _run_pipeline(sample_path.read_text())
        summary = result["properties"]["design_summary"]

        assert "farm_area_ha" in summary
        assert summary["farm_area_ha"] > 0
        assert "total_valves" in summary
        assert summary["total_valves"] >= 1
        assert "pump_hp" in summary
        assert summary["pump_flow_lph"] > 0


# ──────────────────────────────────────────────────────────────────────
# Test 2 & 3: Crop propagation
# ──────────────────────────────────────────────────────────────────────

class TestCropPropagation:
    """Verify crop metadata flows through the pipeline to zone designs."""

    def test_single_crop_appears_in_valves(self, single_crop_input):
        """When input has one crop, all valves should reference that crop."""
        result = _run_pipeline(single_crop_input)
        valves = _features_by_type(result, "valve")

        assert len(valves) >= 1
        for valve in valves:
            assert valve["properties"]["crop"] == "tomato"

    def test_single_crop_in_main_lines(self, single_crop_input):
        """Main lines should carry the crop type from their zone."""
        result = _run_pipeline(single_crop_input)
        mains = _features_by_type(result, "main_line")

        assert len(mains) >= 1
        for main in mains:
            assert "crop" in main["properties"]

    def test_multi_crop_has_both_crops_in_zone_details(self, multi_crop_input):
        """Multi-crop input should produce zone_details mentioning both crops."""
        result = _run_pipeline(multi_crop_input)
        zone_details = result["properties"].get("zone_details", [])

        crops_seen = {z.get("crop") for z in zone_details}
        # Both crops must appear in the zone details
        assert "tomato" in crops_seen, f"Expected 'tomato' in zone crops, got {crops_seen}"
        assert "lettuce" in crops_seen, f"Expected 'lettuce' in zone crops, got {crops_seen}"

    def test_multi_crop_valve_count_at_least_crop_count(self, multi_crop_input):
        """With 2 crops, need at least 2 valves (crop constraint)."""
        result = _run_pipeline(multi_crop_input)
        valves = _features_by_type(result, "valve")
        assert len(valves) >= 2


# ──────────────────────────────────────────────────────────────────────
# Test 4: Centralized vs. distributed
# ──────────────────────────────────────────────────────────────────────

class TestValveStrategy:
    """Verify centralized/distributed flag is respected."""

    def test_explicit_centralized(self):
        """centralized=true should produce centralized valves."""
        features = [
            _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "farm_boundary"}),
            _make_point_feature(PUMP_LON, PUMP_LAT, {"type": "pump", "pump_hp": 5.0}),
        ]
        fc = _make_feature_collection(features, {
            "pump_hp": 5.0,
            "centralized": True,
        })
        result = _run_pipeline(fc)
        valves = _features_by_type(result, "valve")

        assert len(valves) >= 1
        assert all(v["properties"]["strategy"] == "centralized" for v in valves)

    def test_explicit_distributed(self):
        """centralized=false should produce distributed valves."""
        features = [
            _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "farm_boundary"}),
            _make_point_feature(PUMP_LON, PUMP_LAT, {"type": "pump", "pump_hp": 5.0}),
        ]
        fc = _make_feature_collection(features, {
            "pump_hp": 5.0,
            "centralized": False,
        })
        result = _run_pipeline(fc)
        valves = _features_by_type(result, "valve")

        assert len(valves) >= 1
        assert all(v["properties"]["strategy"] == "distributed" for v in valves)

    def test_default_strategy_uses_farm_area(self):
        """Without explicit centralized flag, strategy should reflect farm area."""
        features = [
            _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "farm_boundary"}),
            _make_point_feature(PUMP_LON, PUMP_LAT, {"type": "pump", "pump_hp": 5.0}),
        ]
        # No centralized key at all
        fc = _make_feature_collection(features, {"pump_hp": 5.0})
        result = _run_pipeline(fc)

        # Farm is ~2.4 ha → should default to distributed (>= 1 ha)
        design_type = result["properties"]["design_summary"]["design_type"]
        valves = _features_by_type(result, "valve")
        # design_type must be consistent with valve strategy
        assert design_type == "distributed", f"~2.4ha farm should be distributed, got {design_type}"
        assert all(
            v["properties"]["strategy"] == "distributed" for v in valves
        ), "Valve strategy should match design_type when no explicit flag set"


# ──────────────────────────────────────────────────────────────────────
# Test 5: Elevation split
# ──────────────────────────────────────────────────────────────────────

class TestElevationSplit:
    """Verify topography-driven zone splitting."""

    def test_elevation_delta_adds_valve(self, elevation_input):
        """10m elevation delta (> 5m threshold) should add at least one extra valve."""
        result_elevated = _run_pipeline(elevation_input)
        valves_elevated = _features_by_type(result_elevated, "valve")

        # Compare against same farm without elevation data
        features_flat = [
            _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "farm_boundary"}),
            _make_point_feature(PUMP_LON, PUMP_LAT, {"type": "pump", "pump_hp": 5.0}),
        ]
        fc_flat = _make_feature_collection(features_flat, {"pump_hp": 5.0})
        result_flat = _run_pipeline(fc_flat)
        valves_flat = _features_by_type(result_flat, "valve")

        assert len(valves_elevated) >= len(valves_flat)


# ──────────────────────────────────────────────────────────────────────
# Test 6: BOM accuracy
# ──────────────────────────────────────────────────────────────────────

class TestBOMAccuracy:
    """Verify BOM totals are internally consistent."""

    def test_bom_valves_count_matches_valve_features(self, single_crop_input):
        """BOM valves_count should equal number of valve features in output."""
        result = _run_pipeline(single_crop_input)
        bom = result["properties"]["bom"]
        valve_features = _features_by_type(result, "valve")

        assert bom["valves_count"] == len(valve_features)

    def test_bom_pipe_total_is_sum(self, single_crop_input):
        """total_pipe_m should equal main_line + drip_tape."""
        result = _run_pipeline(single_crop_input)
        bom = result["properties"]["bom"]

        expected_total = bom["main_line_16mm_m"] + bom["drip_tape_16mm_m"]
        assert abs(bom["total_pipe_m"] - expected_total) < 0.1

    def test_bom_cost_breakdown_sums_to_total(self, single_crop_input):
        """If cost fields present, component costs should sum to total."""
        result = _run_pipeline(single_crop_input)
        bom = result["properties"]["bom"]

        if "total_cost_usd" in bom:
            component_sum = (
                bom.get("cost_main", 0)
                + bom.get("cost_drip_tape", 0)
                + bom.get("cost_emitters", 0)
                + bom.get("cost_valves", 0)
            )
            assert abs(bom["total_cost_usd"] - component_sum) < 0.1

    def test_bom_quantities_positive(self, single_crop_input):
        """All BOM quantities should be positive for a valid farm."""
        result = _run_pipeline(single_crop_input)
        bom = result["properties"]["bom"]

        assert bom["main_line_16mm_m"] > 0
        assert bom["drip_tape_16mm_m"] > 0
        assert bom["inline_emitters"] > 0
        assert bom["total_pipe_m"] > 0


# ──────────────────────────────────────────────────────────────────────
# Test 7: Error cases
# ──────────────────────────────────────────────────────────────────────

class TestErrorCases:
    """Verify pipeline returns structured errors for bad input."""

    def test_invalid_json_returns_error(self):
        """Completely invalid JSON should return error response."""
        result = process_farm_design("not json at all")
        assert result["properties"]["type"] == "farm_design_error"

    def test_missing_boundary_returns_error(self):
        """FeatureCollection with no polygon should return error."""
        fc = _make_feature_collection([
            _make_point_feature(77.5, 12.9, {"type": "pump", "pump_hp": 5.0}),
        ], {"pump_hp": 5.0})
        result = _run_pipeline(fc)
        assert result["properties"]["type"] == "farm_design_error"

    def test_missing_pump_returns_error(self):
        """FeatureCollection with no pump point should return error."""
        fc = _make_feature_collection([
            _make_polygon_feature(FARM_BOUNDARY_COORDS, {"type": "farm_boundary"}),
        ])
        # No pump_hp anywhere
        result = _run_pipeline(fc)
        assert result["properties"]["type"] == "farm_design_error"

    def test_empty_features_returns_error(self):
        """Empty features array should return error."""
        fc = {"type": "FeatureCollection", "features": [], "properties": {"pump_hp": 5.0}}
        result = _run_pipeline(fc)
        assert result["properties"]["type"] == "farm_design_error"


# ──────────────────────────────────────────────────────────────────────
# Test 8: Design quality — lateral uniformity
# ──────────────────────────────────────────────────────────────────────

class TestDesignQuality:
    """Metrics-based evaluation of design output quality."""

    def test_lateral_lengths_are_positive(self, single_crop_input):
        """All laterals should have positive length."""
        result = _run_pipeline(single_crop_input)
        laterals = _features_by_type(result, "lateral")

        assert len(laterals) > 0
        for lat in laterals:
            assert lat["properties"]["length_m"] > 0

    def test_lateral_uniformity_within_zone(self, single_crop_input):
        """Within each valve zone, lateral lengths should not vary more than 50x.

        This is a soft quality metric — extreme variation indicates dead zones.
        The 50x threshold accounts for geometric realities of zone edges after
        headland buffering (laterals at edges are naturally shorter).
        DESIGN_LOGIC.md recommends < 1.5x for ideal designs; test uses generous tolerance.
        """
        result = _run_pipeline(single_crop_input)
        laterals = _features_by_type(result, "lateral")

        if len(laterals) < 2:
            pytest.skip("Not enough laterals to measure uniformity")

        # Group laterals by valve_id
        by_valve = {}
        for lat in laterals:
            vid = lat["properties"]["valve_id"]
            by_valve.setdefault(vid, []).append(lat["properties"]["length_m"])

        for valve_id, lengths in by_valve.items():
            if len(lengths) < 2:
                continue
            min_len = min(lengths)
            max_len = max(lengths)
            if min_len > 0:
                ratio = max_len / min_len
                # Very generous threshold to account for zone geometry after headland buffering
                assert ratio < 50, (
                    f"Valve {valve_id}: lateral length ratio {ratio:.1f}x "
                    f"(min={min_len:.1f}m, max={max_len:.1f}m)"
                )

    def test_main_line_within_farm_bounds(self, single_crop_input):
        """Main line endpoints should be within the farm boundary extent."""
        result = _run_pipeline(single_crop_input)
        boundary = _features_by_type(result, "farm_boundary")
        mains = _features_by_type(result, "main_line")

        if not boundary or not mains:
            pytest.skip("Missing boundary or main_line features")

        # Extract lon/lat bounds from farm boundary
        farm_coords = boundary[0]["geometry"]["coordinates"][0]
        lons = [c[0] for c in farm_coords]
        lats = [c[1] for c in farm_coords]
        lon_min, lon_max = min(lons), max(lons)
        lat_min, lat_max = min(lats), max(lats)

        # Small tolerance for coordinate transform rounding
        tol = 0.001  # ~111m at equator — generous for transform artifacts
        for main in mains:
            for coord in main["geometry"]["coordinates"]:
                assert lon_min - tol <= coord[0] <= lon_max + tol, (
                    f"Main line lon {coord[0]} outside farm bounds [{lon_min}, {lon_max}]"
                )
                assert lat_min - tol <= coord[1] <= lat_max + tol, (
                    f"Main line lat {coord[1]} outside farm bounds [{lat_min}, {lat_max}]"
                )

    def test_zone_count_matches_valve_count(self, single_crop_input):
        """Number of valve_zone features should match number of valve features."""
        result = _run_pipeline(single_crop_input)
        valves = _features_by_type(result, "valve")
        zones = _features_by_type(result, "valve_zone")

        # Zones may be fewer if some valves get merged zones, but should never exceed
        assert len(zones) <= len(valves)
        # And there should be at least one zone
        assert len(zones) >= 1

    def test_laterals_are_parallel_across_zones(self, single_crop_input):
        """All laterals should share a consistent orientation across zones."""
        result = _run_pipeline(single_crop_input)
        laterals = _features_by_type(result, "lateral")

        if len(laterals) < 2:
            pytest.skip("Not enough laterals to measure parallelism")

        angles = []
        for lateral in laterals:
            coords = lateral["geometry"]["coordinates"]
            if len(coords) < 2:
                continue
            x1, y1 = coords[0]
            x2, y2 = coords[-1]
            dx = x2 - x1
            dy = y2 - y1
            if dx == 0 and dy == 0:
                continue
            angle = math.atan2(dy, dx) % math.pi
            angles.append(angle)

        if len(angles) < 2:
            pytest.skip("Not enough valid laterals to compare")

        tolerance = math.radians(5)
        reference = angles[0]
        for idx, angle in enumerate(angles[1:], start=1):
            delta = abs(angle - reference)
            delta = min(delta, math.pi - delta)
            assert delta <= tolerance, (
                f"Lateral {idx}: angle differs by {math.degrees(delta):.1f}° "
                f"from reference {math.degrees(reference):.1f}°"
            )


# ──────────────────────────────────────────────────────────────────────
# Test 9: Multi-pump scenarios
# ──────────────────────────────────────────────────────────────────────

# ~310m × 155m rectangle (~4.8 ha) — large enough for multi-pump testing
LARGE_FARM_COORDS = [
    [77.5930, 12.9716],
    [77.5960, 12.9716],
    [77.5960, 12.9730],
    [77.5930, 12.9730],
    [77.5930, 12.9716],
]


def _make_multi_pump_input(pump_configs, farm_coords=None, crop_zones=None):
    """Build a GeoJSON FeatureCollection with multiple pumps.

    Args:
        pump_configs: List of (lon, lat, hp) tuples for each pump.
        farm_coords: Optional farm boundary coords (defaults to LARGE_FARM_COORDS).
        crop_zones: Optional list of (coords, crop_name) tuples.
    """
    if farm_coords is None:
        farm_coords = LARGE_FARM_COORDS

    features = [
        _make_polygon_feature(farm_coords, {"type": "farm_boundary"}),
    ]
    for lon, lat, hp in pump_configs:
        features.append(
            _make_point_feature(lon, lat, {"type": "pump", "pump_hp": hp})
        )
    if crop_zones:
        for coords, crop_name in crop_zones:
            features.append(
                _make_polygon_feature(coords, {"type": "crop_zone", "crop": crop_name})
            )

    return _make_feature_collection(
        features,
        {"pump_hp": pump_configs[0][2], "headland_buffer_m": 1.0},
    )


class TestMultiPump:
    """Validate multi-pump farm partitioning and zone generation."""

    def test_two_pumps_produce_non_overlapping_zones(self):
        """Zones from different sources should not significantly overlap."""
        fc = _make_multi_pump_input([
            (77.5932, 12.9718, 5.0),  # west pump
            (77.5958, 12.9728, 5.0),  # east pump
        ])
        result = _run_pipeline(fc)
        zones = _features_by_type(result, "valve_zone")

        assert len(zones) >= 2, "Multi-pump should produce at least 2 zones"

        # Pairwise overlap check: no pair should overlap by more than 5%
        from shapely.geometry import shape
        zone_polys = [shape(z["geometry"]) for z in zones]
        for i in range(len(zone_polys)):
            for j in range(i + 1, len(zone_polys)):
                overlap = zone_polys[i].intersection(zone_polys[j]).area
                smaller_area = min(zone_polys[i].area, zone_polys[j].area)
                if smaller_area > 0:
                    overlap_pct = overlap / smaller_area
                    assert overlap_pct < 0.05, (
                        f"Zones {i} and {j} overlap by {overlap_pct:.1%}"
                    )

    def test_valve_count_scales_with_service_area(self):
        """Each source's valve count should be proportional to its service area,
        not the total farm area.  With 2 equal pumps on a ~4.8ha farm,
        each should get roughly half the valves."""
        # Single pump baseline
        fc_single = _make_multi_pump_input([
            (77.5945, 12.9723, 5.0),
        ])
        result_single = _run_pipeline(fc_single)
        valves_single = len(_features_by_type(result_single, "valve"))

        # Two equal pumps — total valves should be similar, not doubled
        fc_dual = _make_multi_pump_input([
            (77.5932, 12.9718, 5.0),
            (77.5958, 12.9728, 5.0),
        ])
        result_dual = _run_pipeline(fc_dual)
        valves_dual = len(_features_by_type(result_dual, "valve"))

        # Dual-pump total should not exceed 1.5× single-pump count
        assert valves_dual <= valves_single * 1.5, (
            f"Dual-pump produced {valves_dual} valves vs single-pump {valves_single}; "
            f"expected ≤ {valves_single * 1.5:.0f} (service area scoping)"
        )

    def test_capacity_weighted_partitioning(self):
        """A 10HP pump should get a larger service area than a 5HP pump."""
        fc = _make_multi_pump_input([
            (77.5932, 12.9718, 5.0),   # west — weaker
            (77.5958, 12.9728, 10.0),  # east — stronger
        ])
        result = _run_pipeline(fc)
        zones = _features_by_type(result, "valve_zone")

        # Group zones by source_id would need the internal property;
        # instead check that total valve count >= 2 and zones exist
        valves = _features_by_type(result, "valve")
        assert len(valves) >= 2
        assert len(zones) >= 2
        # Total zone area should approximate farm area
        total_zone_area = sum(z["properties"]["area_m2"] for z in zones)
        assert total_zone_area > 0

    def test_single_pump_unchanged(self):
        """Single-pump farms should behave identically to before."""
        fc = _make_multi_pump_input([
            (77.5946, 12.9716, 5.0),
        ], farm_coords=FARM_BOUNDARY_COORDS)
        result = _run_pipeline(fc)

        assert result["properties"]["type"] == "farm_design"
        valves = _features_by_type(result, "valve")
        zones = _features_by_type(result, "valve_zone")
        assert len(valves) >= 1
        assert len(zones) >= 1
        assert len(zones) <= len(valves)


if __name__ == "__main__":
    pytest.main([__file__, "-v"])