Source code for satorbis_kit.visualization.layers

"""Layer management for STAC visualization."""

import json
from typing import Any, Dict, List, Optional

from .config import VisualizationConfig




class STACLayerManager:
    """Manage layers on a STAC visualization map.

    This class helps organize and control multiple STAC item layers
    on a single map, including layer groups, visibility, and styling.

    Attributes:
        config: Visualization configuration
        layers: Dictionary of managed layers
    """

    def __init__(self, config: VisualizationConfig):
        """Initialize the layer manager.

        Args:
            config: Visualization configuration
        """
        self.config = config
        self.layers: Dict[str, Dict[str, Any]] = {}
        self.layer_groups: Dict[str, List[str]] = {}



    def add_layer(
        self,
        layer_id: str,
        item: Dict,
        tile_url: str,
        group: Optional[str] = None,
        metadata: Optional[Dict] = None,
    ) -> None:
        """Add a layer to the manager.

        Args:
            layer_id: Unique layer identifier
            item: STAC item dictionary
            tile_url: TiTiler tile URL
            group: Optional group name
            metadata: Additional metadata
        """
        self.layers[layer_id] = {
            "item": item,
            "tile_url": tile_url,
            "group": group,
            "metadata": metadata or {},
            "visible": True,
        }

        if group:
            if group not in self.layer_groups:
                self.layer_groups[group] = []
            self.layer_groups[group].append(layer_id)




    def remove_layer(self, layer_id: str) -> None:
        """Remove a layer from the manager.

        Args:
            layer_id: Layer identifier to remove
        """
        if layer_id in self.layers:
            layer = self.layers[layer_id]
            if layer["group"]:
                self.layer_groups[layer["group"]].remove(layer_id)
            del self.layers[layer_id]




    def toggle_layer(self, layer_id: str) -> bool:
        """Toggle layer visibility.

        Args:
            layer_id: Layer identifier

        Returns:
            New visibility state
        """
        if layer_id in self.layers:
            self.layers[layer_id]["visible"] = not self.layers[layer_id]["visible"]
            return self.layers[layer_id]["visible"]
        return False




    def get_layer(self, layer_id: str) -> Optional[Dict]:
        """Get layer information.

        Args:
            layer_id: Layer identifier

        Returns:
            Layer dictionary or None
        """
        return self.layers.get(layer_id)




    def get_layers_in_group(self, group: str) -> List[str]:
        """Get all layer IDs in a group.

        Args:
            group: Group name

        Returns:
            List of layer IDs
        """
        return self.layer_groups.get(group, [])




    def toggle_group(self, group: str) -> None:
        """Toggle visibility of all layers in a group.

        Args:
            group: Group name
        """
        for layer_id in self.get_layers_in_group(group):
            self.toggle_layer(layer_id)




    def clear_all(self) -> None:
        """Clear all layers."""
        self.layers.clear()
        self.layer_groups.clear()




    def get_layer_summary(self) -> Dict[str, Any]:
        """Get summary of all layers.

        Returns:
            Dictionary with layer statistics
        """
        return {
            "total_layers": len(self.layers),
            "groups": list(self.layer_groups.keys()),
            "visible_layers": sum(1 for layer in self.layers.values() if layer["visible"]),
        }