# src/knowledge_graph.py

import networkx as nx
from pyvis.network import Network
import json
from typing import Dict, List, Any, Optional, Set, Tuple
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
from collections import defaultdict

class KnowledgeGraph:
    """
    Handles the construction and visualization of knowledge graphs
    based on the ontology data.
    """
    
    def __init__(self, ontology_manager=None):
        """
        Initialize the knowledge graph handler.
        
        Args:
            ontology_manager: Optional ontology manager instance
        """
        self.ontology_manager = ontology_manager
        self.graph = None
        
        if ontology_manager:
            self.graph = ontology_manager.graph
    
    def build_visualization_graph(
        self, 
        include_classes: bool = True,
        include_instances: bool = True,
        central_entity: Optional[str] = None,
        max_distance: int = 2,
        include_properties: bool = False
    ) -> nx.Graph:
        """
        Build a simplified graph for visualization purposes.
        
        Args:
            include_classes: Whether to include class nodes
            include_instances: Whether to include instance nodes
            central_entity: Optional central entity to focus the graph on
            max_distance: Maximum distance from central entity to include
            include_properties: Whether to include property nodes
            
        Returns:
            A NetworkX graph suitable for visualization
        """
        if not self.graph:
            return nx.Graph()
        
        # Create an undirected graph for visualization
        viz_graph = nx.Graph()
        
        # If we have a central entity, extract a subgraph around it
        if central_entity and central_entity in self.graph:
            # Get nodes within max_distance of central_entity
            nodes_to_include = set([central_entity])
            current_distance = 0
            current_layer = set([central_entity])
            
            while current_distance < max_distance:
                next_layer = set()
                for node in current_layer:
                    # Get neighbors
                    neighbors = set(self.graph.successors(node)).union(set(self.graph.predecessors(node)))
                    next_layer.update(neighbors)
                
                nodes_to_include.update(next_layer)
                current_layer = next_layer
                current_distance += 1
            
            # Create subgraph
            subgraph = self.graph.subgraph(nodes_to_include)
        else:
            subgraph = self.graph
        
        # Add nodes to the visualization graph
        for node, data in subgraph.nodes(data=True):
            node_type = data.get("type")
            
            # Skip nodes based on configuration
            if node_type == "class" and not include_classes:
                continue
            if node_type == "instance" and not include_instances:
                continue
            
            # Get readable name for the node
            if node_type == "instance" and "properties" in data:
                label = data["properties"].get("name", node)
            else:
                label = node
            
            # Set node attributes for visualization
            viz_attrs = {
                "id": node,
                "label": label,
                "title": self._get_node_tooltip(node, data),
                "group": data.get("class_type", node_type),
                "shape": "dot" if node_type == "instance" else "diamond"
            }
            
            # Highlight central entity if specified
            if central_entity and node == central_entity:
                viz_attrs["color"] = "#ff7f0e"  # Orange for central entity
                viz_attrs["size"] = 25  # Larger size for central entity
            
            # Add the node
            viz_graph.add_node(node, **viz_attrs)
            
            # Add property nodes if configured
            if include_properties and node_type == "instance" and "properties" in data:
                for prop_name, prop_value in data["properties"].items():
                    # Create a property node
                    prop_node_id = f"{node}_{prop_name}"
                    prop_value_str = str(prop_value)
                    if len(prop_value_str) > 20:
                        prop_value_str = prop_value_str[:17] + "..."
                    
                    viz_graph.add_node(
                        prop_node_id, 
                        id=prop_node_id,
                        label=f"{prop_name}: {prop_value_str}",
                        title=f"{prop_name}: {prop_value}",
                        group="property",
                        shape="ellipse",
                        size=5
                    )
                    
                    # Connect instance to property
                    viz_graph.add_edge(node, prop_node_id, label="has_property", dashes=True)
        
        # Add edges to the visualization graph
        for source, target, data in subgraph.edges(data=True):
            # Only include edges between nodes that are in the viz_graph
            if source in viz_graph and target in viz_graph:
                # Skip property-related edges if we're manually creating them
                if include_properties and (
                    source.startswith(target + "_") or target.startswith(source + "_")
                ):
                    continue
                
                # Set edge attributes
                edge_type = data.get("type", "unknown")
                
                # Don't show subClassOf and instanceOf relationships if not explicitly requested
                if edge_type in ["subClassOf", "instanceOf"] and not include_classes:
                    continue
                
                viz_graph.add_edge(source, target, label=edge_type, title=edge_type)
        
        return viz_graph
    
    def _get_node_tooltip(self, node_id: str, data: Dict) -> str:
        """Generate a tooltip for a node."""
        tooltip = f"<strong>ID:</strong> {node_id}<br>"
        
        node_type = data.get("type")
        if node_type:
            tooltip += f"<strong>Type:</strong> {node_type}<br>"
        
        if node_type == "instance":
            tooltip += f"<strong>Class:</strong> {data.get('class_type', 'unknown')}<br>"
            
            # Add properties
            if "properties" in data:
                tooltip += "<strong>Properties:</strong><br>"
                for key, value in data["properties"].items():
                    tooltip += f"- {key}: {value}<br>"
        
        elif node_type == "class":
            tooltip += f"<strong>Description:</strong> {data.get('description', '')}<br>"
            
            # Add properties if available
            if "properties" in data:
                tooltip += "<strong>Properties:</strong> " + ", ".join(data["properties"]) + "<br>"
        
        return tooltip
    
    def generate_html_visualization(
        self, 
        include_classes: bool = True,
        include_instances: bool = True,
        central_entity: Optional[str] = None,
        max_distance: int = 2,
        include_properties: bool = False,
        height: str = "600px",
        width: str = "100%",
        bgcolor: str = "#ffffff",
        font_color: str = "#000000",
        layout_algorithm: str = "force-directed"
    ) -> str:
        """
        Generate an HTML visualization of the knowledge graph.
        
        Args:
            include_classes: Whether to include class nodes
            include_instances: Whether to include instance nodes
            central_entity: Optional central entity to focus the graph on
            max_distance: Maximum distance from central entity to include
            include_properties: Whether to include property nodes
            height: Height of the visualization
            width: Width of the visualization
            bgcolor: Background color
            font_color: Font color
            layout_algorithm: Algorithm for layout ('force-directed', 'hierarchical', 'radial', 'circular')
            
        Returns:
            HTML string containing the visualization
        """
        # Build the visualization graph
        viz_graph = self.build_visualization_graph(
            include_classes=include_classes,
            include_instances=include_instances,
            central_entity=central_entity,
            max_distance=max_distance,
            include_properties=include_properties
        )
        
        # Create a PyVis network
        net = Network(height=height, width=width, bgcolor=bgcolor, font_color=font_color, directed=True)
        
        # Configure physics based on the selected layout algorithm
        if layout_algorithm == "force-directed":
            physics_options = {
                "enabled": True,
                "solver": "forceAtlas2Based",
                "forceAtlas2Based": {
                    "gravitationalConstant": -50,
                    "centralGravity": 0.01,
                    "springLength": 100,
                    "springConstant": 0.08
                },
                "stabilization": {
                    "enabled": True,
                    "iterations": 100
                }
            }
        elif layout_algorithm == "hierarchical":
            physics_options = {
                "enabled": True,
                "hierarchicalRepulsion": {
                    "centralGravity": 0.0,
                    "springLength": 100,
                    "springConstant": 0.01,
                    "nodeDistance": 120
                },
                "solver": "hierarchicalRepulsion",
                "stabilization": {
                    "enabled": True,
                    "iterations": 100
                }
            }
            
            # Set hierarchical layout
            net.set_options("""
                var options = {
                    "layout": {
                        "hierarchical": {
                            "enabled": true,
                            "direction": "UD",
                            "sortMethod": "directed",
                            "nodeSpacing": 150,
                            "treeSpacing": 200
                        }
                    }
                }
            """)
        elif layout_algorithm == "radial":
            physics_options = {
                "enabled": True,
                "solver": "repulsion",
                "repulsion": {
                    "nodeDistance": 120,
                    "centralGravity": 0.2,
                    "springLength": 200,
                    "springConstant": 0.05
                },
                "stabilization": {
                    "enabled": True,
                    "iterations": 100
                }
            }
        elif layout_algorithm == "circular":
            physics_options = {
                "enabled": False
            }
            
            # Compute circular layout and set fixed positions
            pos = nx.circular_layout(viz_graph)
            for node_id, coords in pos.items():
                if node_id in viz_graph.nodes:
                    x, y = coords
                    viz_graph.nodes[node_id]['x'] = float(x) * 500
                    viz_graph.nodes[node_id]['y'] = float(y) * 500
                    viz_graph.nodes[node_id]['physics'] = False
        
        # Configure other options
        options = {
            "nodes": {
                "font": {"size": 12},
                "scaling": {"min": 10, "max": 30}
            },
            "edges": {
                "color": {"inherit": True},
                "smooth": {"enabled": True, "type": "dynamic"},
                "arrows": {"to": {"enabled": True, "scaleFactor": 0.5}},
                "font": {"size": 10, "align": "middle"}
            },
            "physics": physics_options,
            "interaction": {
                "hover": True,
                "navigationButtons": True,
                "keyboard": True,
                "tooltipDelay": 100
            }
        }
        
        # Set options and create the network
        net.options = options
        net.from_nx(viz_graph)
        
        # Add custom CSS for better visualization
        custom_css = """
        <style>
          .vis-network {
            border: 1px solid #ddd;
            border-radius: 5px;
          }
          .vis-tooltip {
            position: absolute;
            background-color: #f5f5f5;
            border: 1px solid #ccc;
            border-radius: 4px;
            padding: 10px;
            font-family: Arial, sans-serif;
            font-size: 12px;
            color: #333;
            max-width: 300px;
            z-index: 9999;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
          }
        </style>
        """
        
        # Generate the HTML and add custom CSS
        html = net.generate_html()
        html = html.replace("<style>", custom_css + "<style>")
        
        # Add legend
        legend_html = self._generate_legend_html(viz_graph)
        html = html.replace("</body>", legend_html + "</body>")
        
        return html
    
    def _generate_legend_html(self, graph: nx.Graph) -> str:
        """Generate a legend for the visualization."""
        # Collect unique groups
        groups = set()
        for _, attrs in graph.nodes(data=True):
            if "group" in attrs:
                groups.add(attrs["group"])
        
        # Generate HTML for legend
        legend_html = """
        <div id="graph-legend" style="position: absolute; top: 10px; right: 10px; background-color: rgba(255,255,255,0.8); 
                                    padding: 10px; border-radius: 5px; border: 1px solid #ddd; max-width: 200px;">
            <strong>Legend:</strong>
            <ul style="list-style-type: none; padding-left: 0; margin-top: 5px;">
        """
        
        # Add items for each group
        for group in sorted(groups):
            color = "#97c2fc"  # Default color
            if group == "property":
                color = "#ffcc99"
            elif group == "class":
                color = "#a1d3a2"
            
            legend_html += f"""
                <li style="margin-bottom: 5px;">
                    <span style="display: inline-block; width: 12px; height: 12px; border-radius: 50%; 
                                background-color: {color}; margin-right: 5px;"></span>
                    {group}
                </li>
            """
        
        # Close the legend container
        legend_html += """
            </ul>
            <div style="font-size: 10px; margin-top: 5px; color: #666;">
                Double-click to zoom, drag to pan, scroll to zoom in/out
            </div>
        </div>
        """
        
        return legend_html
    
    def get_graph_statistics(self) -> Dict[str, Any]:
        """
        Calculate statistics about the knowledge graph.
        
        Returns:
            A dictionary containing graph statistics
        """
        if not self.graph:
            return {}
        
        # Count nodes by type
        class_count = 0
        instance_count = 0
        property_count = 0
        
        for _, data in self.graph.nodes(data=True):
            node_type = data.get("type")
            if node_type == "class":
                class_count += 1
            elif node_type == "instance":
                instance_count += 1
                if "properties" in data:
                    property_count += len(data["properties"])
        
        # Count edges by type
        relationship_counts = {}
        for _, _, data in self.graph.edges(data=True):
            rel_type = data.get("type", "unknown")
            relationship_counts[rel_type] = relationship_counts.get(rel_type, 0) + 1
        
        # Calculate graph metrics
        try:
            # Some metrics only work on undirected graphs
            undirected = nx.Graph(self.graph)
            avg_degree = sum(dict(undirected.degree()).values()) / undirected.number_of_nodes()
            
            # Only calculate these if the graph is connected
            if nx.is_connected(undirected):
                avg_path_length = nx.average_shortest_path_length(undirected)
                diameter = nx.diameter(undirected)
            else:
                # Get the largest connected component
                largest_cc = max(nx.connected_components(undirected), key=len)
                largest_cc_subgraph = undirected.subgraph(largest_cc)
                
                avg_path_length = nx.average_shortest_path_length(largest_cc_subgraph)
                diameter = nx.diameter(largest_cc_subgraph)
                
            # Calculate density
            density = nx.density(self.graph)
            
            # Calculate clustering coefficient
            clustering = nx.average_clustering(undirected)
        except:
            avg_degree = 0
            avg_path_length = 0
            diameter = 0
            density = 0
            clustering = 0
        
        # Count different entity types
        class_counts = defaultdict(int)
        for _, data in self.graph.nodes(data=True):
            if data.get("type") == "instance":
                class_type = data.get("class_type", "unknown")
                class_counts[class_type] += 1
        
        # Get nodes with highest centrality
        try:
            betweenness = nx.betweenness_centrality(self.graph)
            degree = nx.degree_centrality(self.graph)
            
            # Get top 5 nodes by betweenness centrality
            top_betweenness = sorted(betweenness.items(), key=lambda x: x[1], reverse=True)[:5]
            top_degree = sorted(degree.items(), key=lambda x: x[1], reverse=True)[:5]
            
            central_nodes = {
                "betweenness": [{"node": node, "centrality": round(cent, 3)} for node, cent in top_betweenness],
                "degree": [{"node": node, "centrality": round(cent, 3)} for node, cent in top_degree]
            }
        except:
            central_nodes = {}
        
        return {
            "node_count": self.graph.number_of_nodes(),
            "edge_count": self.graph.number_of_edges(),
            "class_count": class_count,
            "instance_count": instance_count,
            "property_count": property_count,
            "relationship_counts": relationship_counts,
            "class_instance_counts": dict(class_counts),
            "average_degree": avg_degree,
            "average_path_length": avg_path_length,
            "diameter": diameter,
            "density": density,
            "clustering_coefficient": clustering,
            "central_nodes": central_nodes
        }
    
    def find_paths_between_entities(
        self, 
        source_entity: str, 
        target_entity: str, 
        max_length: int = 3
    ) -> List[List[Dict]]:
        """
        Find all paths between two entities up to a maximum length.
        
        Args:
            source_entity: Starting entity ID
            target_entity: Target entity ID
            max_length: Maximum path length
            
        Returns:
            A list of paths, where each path is a list of edge dictionaries
        """
        if not self.graph or source_entity not in self.graph or target_entity not in self.graph:
            return []
        
        # Use networkx to find simple paths
        try:
            simple_paths = list(nx.all_simple_paths(
                self.graph, source_entity, target_entity, cutoff=max_length
            ))
        except (nx.NetworkXNoPath, nx.NodeNotFound):
            return []
        
        # Convert paths to edge sequences
        paths = []
        for path in simple_paths:
            edge_sequence = []
            for i in range(len(path) - 1):
                source = path[i]
                target = path[i + 1]
                
                # There may be multiple edges between nodes
                edges = self.graph.get_edge_data(source, target)
                if edges:
                    for key, data in edges.items():
                        edge_sequence.append({
                            "source": source,
                            "target": target,
                            "type": data.get("type", "unknown")
                        })
            
            # Only include the path if it has meaningful relationships
            # Filter out paths that only contain structural relationships like subClassOf, instanceOf
            meaningful_relationships = [edge for edge in edge_sequence 
                                      if edge["type"] not in ["subClassOf", "instanceOf"]]
            
            if meaningful_relationships:
                paths.append(edge_sequence)
        
        # Sort paths by length (shorter paths first)
        paths.sort(key=len)
        
        return paths
    
    def get_entity_neighborhood(
        self, 
        entity_id: str, 
        max_distance: int = 1,
        include_classes: bool = True
    ) -> Dict[str, Any]:
        """
        Get the neighborhood of an entity.
        
        Args:
            entity_id: The central entity ID
            max_distance: Maximum distance from the central entity
            include_classes: Whether to include class relationships
            
        Returns:
            A dictionary containing the neighborhood information
        """
        if not self.graph or entity_id not in self.graph:
            return {}
        
        # Get nodes within max_distance of entity_id using BFS
        nodes_at_distance = {0: [entity_id]}
        visited = set([entity_id])
        
        for distance in range(1, max_distance + 1):
            nodes_at_distance[distance] = []
            
            for node in nodes_at_distance[distance - 1]:
                # Get neighbors
                neighbors = list(self.graph.successors(node)) + list(self.graph.predecessors(node))
                
                for neighbor in neighbors:
                    # Skip class nodes if not including classes
                    neighbor_data = self.graph.nodes.get(neighbor, {})
                    if not include_classes and neighbor_data.get("type") == "class":
                        continue
                    
                    if neighbor not in visited:
                        nodes_at_distance[distance].append(neighbor)
                        visited.add(neighbor)
        
        # Flatten the nodes
        all_nodes = [node for nodes in nodes_at_distance.values() for node in nodes]
        
        # Extract the subgraph
        subgraph = self.graph.subgraph(all_nodes)
        
        # Build neighbor information
        neighbors = []
        for node in all_nodes:
            if node == entity_id:
                continue
                
            node_data = self.graph.nodes[node]
            
            # Determine the relations to central entity
            relations = []
            
            # Check direct relationships
            # Check if central entity is source
            edges_out = self.graph.get_edge_data(entity_id, node)
            if edges_out:
                for key, data in edges_out.items():
                    rel_type = data.get("type", "unknown")
                    
                    # Skip structural relationships if not including classes
                    if not include_classes and rel_type in ["subClassOf", "instanceOf"]:
                        continue
                    
                    relations.append({
                        "type": rel_type,
                        "direction": "outgoing"
                    })
            
            # Check if central entity is target
            edges_in = self.graph.get_edge_data(node, entity_id)
            if edges_in:
                for key, data in edges_in.items():
                    rel_type = data.get("type", "unknown")
                    
                    # Skip structural relationships if not including classes
                    if not include_classes and rel_type in ["subClassOf", "instanceOf"]:
                        continue
                    
                    relations.append({
                        "type": rel_type,
                        "direction": "incoming"
                    })
            
            # Also find paths through intermediate nodes (indirect relationships)
            if not relations:  # Only look for indirect if no direct relationships
                for path_length in range(2, max_distance + 1):
                    try:
                        # Find paths of exactly length path_length
                        paths = list(nx.all_simple_paths(
                            self.graph, entity_id, node, cutoff=path_length, min_edges=path_length
                        ))
                        
                        for path in paths:
                            if len(path) > 1:  # Path should have at least 2 nodes
                                intermediate_nodes = path[1:-1]  # Skip source and target
                                
                                # Format the path as a relation
                                path_relation = {
                                    "type": "indirect_connection",
                                    "direction": "outgoing",
                                    "path_length": len(path) - 1,
                                    "intermediates": intermediate_nodes
                                }
                                
                                relations.append(path_relation)
                                
                                # Only need one example of an indirect path
                                break
                    except (nx.NetworkXNoPath, nx.NodeNotFound):
                        pass
            
            # Only include neighbors with relations
            if relations:
                neighbors.append({
                    "id": node,
                    "type": node_data.get("type"),
                    "class_type": node_data.get("class_type"),
                    "properties": node_data.get("properties", {}),
                    "relations": relations,
                    "distance": next(dist for dist, nodes in nodes_at_distance.items() if node in nodes)
                })
        
        # Group neighbors by distance
        neighbors_by_distance = defaultdict(list)
        for neighbor in neighbors:
            neighbors_by_distance[neighbor["distance"]].append(neighbor)
        
        # Get central entity info
        central_data = self.graph.nodes[entity_id]
        
        return {
            "central_entity": {
                "id": entity_id,
                "type": central_data.get("type"),
                "class_type": central_data.get("class_type", ""),
                "properties": central_data.get("properties", {})
            },
            "neighbors": neighbors,
            "neighbors_by_distance": dict(neighbors_by_distance),
            "total_neighbors": len(neighbors)
        }
    
    def find_common_patterns(self) -> List[Dict[str, Any]]:
        """
        Find common patterns and structures in the knowledge graph.
        
        Returns:
            A list of pattern dictionaries
        """
        if not self.graph:
            return []
        
        patterns = []
        
        # Find common relationship patterns
        relationship_patterns = self._find_relationship_patterns()
        if relationship_patterns:
            patterns.extend(relationship_patterns)
        
        # Find hub entities (entities with many connections)
        hub_entities = self._find_hub_entities()
        if hub_entities:
            patterns.append({
                "type": "hub_entities",
                "description": "Entities with high connectivity serving as knowledge hubs",
                "entities": hub_entities
            })
        
        # Find common property patterns
        property_patterns = self._find_property_patterns()
        if property_patterns:
            patterns.extend(property_patterns)
        
        return patterns
    
    def _find_relationship_patterns(self) -> List[Dict[str, Any]]:
        """Find common relationship patterns in the graph."""
        # Count relationship triplets (source_type, relation, target_type)
        triplet_counts = defaultdict(int)
        
        for source, target, data in self.graph.edges(data=True):
            rel_type = data.get("type", "unknown")
            
            # Skip structural relationships
            if rel_type in ["subClassOf", "instanceOf"]:
                continue
            
            # Get node types
            source_data = self.graph.nodes[source]
            target_data = self.graph.nodes[target]
            
            source_type = (
                source_data.get("class_type")
                if source_data.get("type") == "instance"
                else source_data.get("type")
            )
            
            target_type = (
                target_data.get("class_type")
                if target_data.get("type") == "instance"
                else target_data.get("type")
            )
            
            if source_type and target_type:
                triplet = (source_type, rel_type, target_type)
                triplet_counts[triplet] += 1
        
        # Get patterns with significant frequency (more than 1 occurrence)
        patterns = []
        for triplet, count in triplet_counts.items():
            if count > 1:
                source_type, rel_type, target_type = triplet
                
                # Find examples of this pattern
                examples = []
                for source, target, data in self.graph.edges(data=True):
                    if len(examples) >= 3:  # Limit to 3 examples
                        break
                        
                    rel = data.get("type", "unknown")
                    if rel != rel_type:
                        continue
                    
                    source_data = self.graph.nodes[source]
                    target_data = self.graph.nodes[target]
                    
                    current_source_type = (
                        source_data.get("class_type")
                        if source_data.get("type") == "instance"
                        else source_data.get("type")
                    )
                    
                    current_target_type = (
                        target_data.get("class_type")
                        if target_data.get("type") == "instance"
                        else target_data.get("type")
                    )
                    
                    if current_source_type == source_type and current_target_type == target_type:
                        # Get readable names if available
                        source_name = source
                        if source_data.get("type") == "instance" and "properties" in source_data:
                            properties = source_data["properties"]
                            if "name" in properties:
                                source_name = properties["name"]
                        
                        target_name = target
                        if target_data.get("type") == "instance" and "properties" in target_data:
                            properties = target_data["properties"]
                            if "name" in properties:
                                target_name = properties["name"]
                        
                        examples.append({
                            "source": source,
                            "source_name": source_name,
                            "target": target,
                            "target_name": target_name,
                            "relationship": rel_type
                        })
                
                patterns.append({
                    "type": "relationship_pattern",
                    "description": f"{source_type} {rel_type} {target_type}",
                    "source_type": source_type,
                    "relationship": rel_type,
                    "target_type": target_type,
                    "count": count,
                    "examples": examples
                })
        
        # Sort by frequency
        patterns.sort(key=lambda x: x["count"], reverse=True)
        
        return patterns
    
    def _find_hub_entities(self) -> List[Dict[str, Any]]:
        """Find entities that serve as hubs (many connections)."""
        # Calculate degree centrality
        degree = nx.degree_centrality(self.graph)
        
        # Get top entities by degree
        top_entities = sorted(degree.items(), key=lambda x: x[1], reverse=True)[:10]
        
        hub_entities = []
        for node, centrality in top_entities:
            node_data = self.graph.nodes[node]
            node_type = node_data.get("type")
            
            # Only consider instance nodes
            if node_type == "instance":
                # Get class type
                class_type = node_data.get("class_type", "unknown")
                
                # Get name if available
                name = node
                if "properties" in node_data and "name" in node_data["properties"]:
                    name = node_data["properties"]["name"]
                
                # Count relationships by type
                relationships = defaultdict(int)
                for _, _, data in self.graph.edges(data=True, nbunch=[node]):
                    rel_type = data.get("type", "unknown")
                    if rel_type not in ["subClassOf", "instanceOf"]:
                        relationships[rel_type] += 1
                
                hub_entities.append({
                    "id": node,
                    "name": name,
                    "type": class_type,
                    "centrality": centrality,
                    "relationships": dict(relationships),
                    "total_connections": sum(relationships.values())
                })
        
        # Sort by total connections
        hub_entities.sort(key=lambda x: x["total_connections"], reverse=True)
        
        return hub_entities
    
    def _find_property_patterns(self) -> List[Dict[str, Any]]:
        """Find common property patterns in instance data."""
        # Track properties by class type
        properties_by_class = defaultdict(lambda: defaultdict(int))
        
        for node, data in self.graph.nodes(data=True):
            if data.get("type") == "instance":
                class_type = data.get("class_type", "unknown")
                
                if "properties" in data:
                    for prop in data["properties"].keys():
                        properties_by_class[class_type][prop] += 1
        
        # Find common property combinations
        patterns = []
        for class_type, props in properties_by_class.items():
            # Sort properties by frequency
            sorted_props = sorted(props.items(), key=lambda x: x[1], reverse=True)
            
            # Only include classes with multiple instances
            class_instances = sum(1 for _, data in self.graph.nodes(data=True)
                                if data.get("type") == "instance" and data.get("class_type") == class_type)
            
            if class_instances > 1:
                common_props = [prop for prop, count in sorted_props if count > 1]
                
                if common_props:
                    patterns.append({
                        "type": "property_pattern",
                        "description": f"Common properties for {class_type} instances",
                        "class_type": class_type,
                        "instance_count": class_instances,
                        "common_properties": common_props,
                        "property_frequencies": {prop: count for prop, count in sorted_props}
                    })
        
        return patterns