Searching Kits via FKAPI

from footycollect.api.client import FKAPIClient

client = FKAPIClient()
results = client.search_kits("arsenal home 2023")

def search_kits(self, query: str) -> list[dict]:
    """Search kits by name."""
    logger.info("Searching kits with query: '%s'", query)
    result = self._get("/kits/search", params={"keyword": query})
    
    if result is None:
        logger.warning("FKAPI unavailable, returning empty results for kit search")
        return []
    
    results = self._extract_list_from_result(result)
    logger.info("Search returned %s results", len(results))
    return results

clubs = client.search_clubs("manchester")
# Returns list of clubs matching "manchester"
# Example: [{"id": 123, "name": "Manchester United", "country": "England", ...}]

def search_clubs(self, query: str) -> list[dict]:
    """Search clubs by name."""
    result = self._get("/clubs/search", params={"keyword": query})
    return self._extract_list_from_result(result)

brands = client.search_brands("nike")
# Returns list of brands matching "nike"

if result is None:
    logger.warning("FKAPI unavailable, trying alternative method for brand search")
    kits = self.search_kits(query)
    brands = {}
    for kit in kits:
        brand = kit.get("brand") or kit.get("team", {}).get("brand")
        if brand:
            brand_name = brand.get("name") if isinstance(brand, dict) else brand
            if brand_name and brand_name not in brands:
                brands[brand_name] = {
                    "id": brand.get("id") if isinstance(brand, dict) else None,
                    "name": brand_name,
                }
    return list(brands.values())

competitions = client.search_competitions("champions league")
# Returns list of competitions matching "champions league"

# From views.py:66-79
@require_GET
def search_kits(request):
    query = request.GET.get("keyword", "")
    min_query_length = 3
    if len(query) < min_query_length:
        return JsonResponse({"results": []})
    
    client = FKAPIClient()
    results = client.search_kits(query)
    return JsonResponse({"results": results})

[
  {
    "id": 12345,
    "name": "Arsenal Home 2023-24",
    "slug": "arsenal-home-2023-24",
    "team": {
      "id": 1,
      "name": "Arsenal",
      "country": "England",
      "logo": "https://example.com/logos/arsenal.png"
    },
    "season": {
      "id": 100,
      "year": "2023-24"
    },
    "brand": {
      "id": 5,
      "name": "Adidas",
      "logo": "https://example.com/logos/adidas.png"
    },
    "type": "Home",
    "competition": [
      {
        "id": 10,
        "name": "Premier League"
      }
    ],
    "main_img_url": "https://example.com/kits/arsenal-home-2023.jpg",
    "kitcolor1": "RED",
    "kitcolor2": "WHITE",
    "design": "plain"
  }
]

[
  {
    "id": 1,
    "name": "Arsenal",
    "slug": "arsenal",
    "country": "England",
    "logo": "https://example.com/logos/arsenal.png",
    "logo_dark": "https://example.com/logos/arsenal-dark.png"
  }
]

// Search kits as user types
fetch('/fkapi/kits/search/?keyword=arsenal')
  .then(response => response.json())
  .then(data => {
    console.log(data.results); // Array of kit objects
  });

seasons = client.get_club_seasons(club_id=1)
# Returns: [{"id": 100, "year": "2023-24"}, {"id": 99, "year": "2022-23"}, ...]

def get_club_seasons(self, club_id: int) -> list[dict]:
    """Get seasons for a club."""
    result = self._get("/seasons", params={"id": club_id})
    return self._extract_list_from_result(result)

kits = client.get_club_kits(club_id=1, season_id=100)
# Returns list of kits for Arsenal in 2023-24 season

def get_club_kits(self, club_id: int, season_id: int) -> list[dict]:
    """Get kits for a club for a specific season."""
    endpoint = f"/clubs/{club_id}/kits"
    params = {"season": season_id}
    result = self._get(endpoint, params=params)
    return self._extract_list_from_result(result)

kit_details = client.get_kit_details(kit_id=12345)
# Returns full kit object with all metadata

# Force fresh data (bypass cache)
kit_details = client.get_kit_details(kit_id=12345, use_cache=False)

def get_kit_details(self, kit_id: int, *, use_cache: bool = True) -> dict | None:
    """Get complete details of a kit."""
    return self._get(f"/kits/{kit_id}", use_cache=use_cache)

# 1. Find club
clubs = client.search_clubs("barcelona")
club_id = clubs[0]['id'] if clubs else None

if club_id:
    # 2. Get available seasons
    seasons = client.get_club_seasons(club_id)
    
    # 3. Get kits for latest season
    if seasons:
        latest_season = seasons[0]['id']
        kits = client.get_club_kits(club_id, latest_season)
        print(f"Found {len(kits)} kits for latest season")

# Use cached results for fast browsing
kits = client.search_kits("liverpool")

# Force fresh results for critical operations
kit_details = client.get_kit_details(
    kit_id=12345,
    use_cache=False  # Bypass cache
)

def safe_kit_search(query: str) -> list[dict]:
    client = FKAPIClient()
    
    try:
        results = client.search_kits(query)
        
        # Handle None (FKAPI unavailable)
        if results is None:
            logger.warning(f"FKAPI unavailable for query: {query}")
            return []
        
        # Handle empty results
        if not results:
            logger.info(f"No kits found for query: {query}")
            return []
        
        return results
        
    except Exception as e:
        logger.exception(f"Error searching kits: {e}")
        return []