"""
  Tests for aggregation API functionality.
  """
  
  import pytest
  from fastapi.testclient import TestClient
  from api.app import app
  
  client = TestClient(app)
  
  
  @pytest.mark.integration
  @pytest.mark.api
  def test_search_with_aggregations():
      """Test search with dynamic aggregations."""
      request_data = {
          "query": "芭比娃娃",
          "size": 10,
          "aggregations": {
              "category_name": {
                  "type": "terms",
                  "field": "categoryName_keyword",
                  "size": 10
              },
              "brand_name": {
                  "type": "terms",
                  "field": "brandName_keyword",
                  "size": 10
              },
              "price_ranges": {
                  "type": "range",
                  "field": "price",
                  "ranges": [
                      {"key": "0-50", "to": 50},
                      {"key": "50-100", "from": 50, "to": 100},
                      {"key": "100-200", "from": 100, "to": 200},
                      {"key": "200+", "from": 200}
                  ]
              }
          }
      }
  
      response = client.post("/search/", json=request_data)
  
      assert response.status_code == 200
      data = response.json()
  
      # Check basic search response structure
      assert "hits" in data
      assert "total" in data
      assert "aggregations" in data
      assert "query_info" in data
  
      # Check aggregations structure
      aggregations = data["aggregations"]
  
      # Should have category aggregations
      if "category_name" in aggregations:
          assert "buckets" in aggregations["category_name"]
          assert isinstance(aggregations["category_name"]["buckets"], list)
  
      # Should have brand aggregations
      if "brand_name" in aggregations:
          assert "buckets" in aggregations["brand_name"]
          assert isinstance(aggregations["brand_name"]["buckets"], list)
  
      # Should have price range aggregations
      if "price_ranges" in aggregations:
          assert "buckets" in aggregations["price_ranges"]
          assert isinstance(aggregations["price_ranges"]["buckets"], list)
  
  
  @pytest.mark.integration
  @pytest.mark.api
  def test_search_with_sorting():
      """Test search with different sorting options."""
  
      # Test price ascending
      request_data = {
          "query": "玩具",
          "size": 5,
          "sort_by": "price_asc"
      }
  
      response = client.post("/search/", json=request_data)
      assert response.status_code == 200
      data = response.json()
  
      if data["hits"] and len(data["hits"]) > 1:
          # Check if results are sorted by price (ascending)
          prices = []
          for hit in data["hits"]:
              if "_source" in hit and "price" in hit["_source"]:
                  prices.append(hit["_source"]["price"])
  
          if len(prices) > 1:
              assert prices == sorted(prices), "Results should be sorted by price ascending"
  
      # Test price descending
      request_data["sort_by"] = "price_desc"
      response = client.post("/search/", json=request_data)
      assert response.status_code == 200
      data = response.json()
  
      if data["hits"] and len(data["hits"]) > 1:
          prices = []
          for hit in data["hits"]:
              if "_source" in hit and "price" in hit["_source"]:
                  prices.append(hit["_source"]["price"])
  
          if len(prices) > 1:
              assert prices == sorted(prices, reverse=True), "Results should be sorted by price descending"
  
      # Test time descending
      request_data["sort_by"] = "time_desc"
      response = client.post("/search/", json=request_data)
      assert response.status_code == 200
      data = response.json()
  
      if data["hits"] and len(data["hits"]) > 1:
          times = []
          for hit in data["hits"]:
              if "_source" in hit and "create_time" in hit["_source"]:
                  times.append(hit["_source"]["create_time"])
  
          if len(times) > 1:
              # Newer items should come first
              assert times == sorted(times, reverse=True), "Results should be sorted by time descending"
  
  
  @pytest.mark.integration
  @pytest.mark.api
  def test_search_with_filters_and_aggregations():
      """Test search with filters and aggregations together."""
      request_data = {
          "query": "玩具",
          "size": 10,
          "filters": {
              "category_name": ["芭比"]
          },
          "aggregations": {
              "brand_name": {
                  "type": "terms",
                  "field": "brandName_keyword",
                  "size": 10
              }
          }
      }
  
      response = client.post("/search/", json=request_data)
      assert response.status_code == 200
      data = response.json()
  
      # Check that results are filtered
      assert "hits" in data
      for hit in data["hits"]:
          if "_source" in hit and "categoryName" in hit["_source"]:
              assert "芭比" in hit["_source"]["categoryName"]
  
      # Check that aggregations are still present
      assert "aggregations" in data
  
  
  @pytest.mark.integration
  @pytest.mark.api
  def test_search_without_aggregations():
      """Test search without aggregations (default behavior)."""
      request_data = {
          "query": "玩具",
          "size": 10
      }
  
      response = client.post("/search/", json=request_data)
      assert response.status_code == 200
      data = response.json()
  
      # Should still have basic response structure
      assert "hits" in data
      assert "total" in data
      assert "query_info" in data
  
      # Aggregations might be empty or not present without explicit request
      assert "aggregations" in data
  
  
  @pytest.mark.integration
  @pytest.mark.api
  def test_aggregation_edge_cases():
      """Test aggregation edge cases."""
  
      # Test with empty query
      request_data = {
          "query": "",
          "size": 10,
          "aggregations": {
              "category_name": {
                  "type": "terms",
                  "field": "categoryName_keyword",
                  "size": 10
              }
          }
      }
  
      response = client.post("/search/", json=request_data)
      # Should handle empty query gracefully
      assert response.status_code in [200, 422]
  
      # Test with invalid aggregation type
      request_data = {
          "query": "玩具",
          "size": 10,
          "aggregations": {
              "invalid_agg": {
                  "type": "invalid_type",
                  "field": "categoryName_keyword",
                  "size": 10
              }
          }
      }
  
      response = client.post("/search/", json=request_data)
      # Should handle invalid aggregation type gracefully
      assert response.status_code in [200, 422]
  
  
  @pytest.mark.unit
  def test_aggregation_spec_validation():
      """Test aggregation specification validation."""
      from api.models import AggregationSpec
  
      # Test valid aggregation spec
      agg_spec = AggregationSpec(
          field="categoryName_keyword",
          type="terms",
          size=10
      )
      assert agg_spec.field == "categoryName_keyword"
      assert agg_spec.type == "terms"
      assert agg_spec.size == 10
  
      # Test range aggregation spec
      range_agg = AggregationSpec(
          field="price",
          type="range",
          ranges=[
              {"key": "0-50", "to": 50},
              {"key": "50-100", "from": 50, "to": 100}
          ]
      )
      assert range_agg.field == "price"
      assert range_agg.type == "range"
      assert len(range_agg.ranges) == 2
  
  
  if __name__ == "__main__":
      pytest.main([__file__])