# Загрузка библиотек
import pandas as pd
import numpy as np

from typing import Dict, List, Tuple, Any
import json
from dataclasses import dataclass
from enum import Enum
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import pairwise_distances
from scipy import stats

# Модуль интерпретации кластеров пермиссий Tessa

# КОНСТАНТЫ И КОНФИГУРАЦИЯ

class ClusterType(Enum):
    """Типы кластеров на основе бизнес-логики"""
    NORMAL = "Нормативный"           # Типичный, предсказуемый паттерн
    ANOMALOUS = "Аномальный"         # Редкий, но легитимный
    RISKY = "Рисковый"               # Нарушение принципа наименьших привилегий
    ERRONEOUS = "Ошибочный"          # Вероятная ошибка конфигурации
    UNIQUE = "Уникальный"            # Единичные/специфичные случаи
    PRIVILEGED = "Привилегированный" # Высокий уровень доступа

class RiskLevel(Enum):
    """Уровни риска безопасности"""
    CRITICAL = "Критический"    # P0 - немедленное действие
    HIGH = "Высокий"           # P1 - срочная оптимизация
    MEDIUM = "Средний"         # P2 - плановая оптимизация
    LOW = "Низкий"             # P3 - мониторинг
    INFO = "Информационный"    # P4 - документирование

@dataclass
class ClusterInterpretationConfig:
    """Конфигурация модуля интерпретации"""
    # Пороговые значения для классификации
    silhouette_threshold: float = 0.5      # Минимальная силуэтная оценка для нормальных кластеров
    size_threshold: float = 0.01           # Минимальная доля объектов в кластере (1%)
    privilege_ratio_threshold: float = 0.7 # Порог для выявления привилегированных кластеров
    consistency_threshold: float = 0.6     # Порог согласованности методов
    
    # Бизнес-параметры
    sensitive_operations: List[str] = None # Чувствительные операции
    
    def __post_init__(self):
        if self.sensitive_operations is None:
            self.sensitive_operations = ['Чтение карточки', 
                                         'Редактирование карточки', 
                                         'Удаление карточки', 
                                         'Редактирование всех файлов', 
                                         'Удаление всех файлов', 
                                         'Редактирование собственных файлов', 
                                         'Удаление собственных файлов']

# ОСНОВНОЙ КЛАСС ИНТЕРПРЕТАТОРА

class PermissionClusterInterpreter:
    """
    Класс для интерпретации математических кластеров в бизнес-контексте.
    
    Преобразует результаты кластеризации HDBSCAN/OPTICS/DBSCAN в:
    1. Бизнес-описания паттернов доступа
    2. Оценки рисков безопасности
    3. Практические рекомендации для разных стейкхолдеров
    
    Методология основана на принципах:
    - Role-Based Access Control (RBAC)
    - Principle of Least Privilege (PoLP)
    - User Behavior Analytics (UBA)
    """
    
    def __init__(self, config: ClusterInterpretationConfig = None):
        """
        Инициализация интерпретатора.
        
        Args:
            config: Конфигурация интерпретатора
        """
        self.config = config or ClusterInterpretationConfig()
        self.cluster_descriptions = {}
        self.risk_assessments = {}
        self.recommendations = {}
        
        # Статистика для аудита
        self.interpretation_stats = {
            'total_clusters': 0,
            'risky_clusters': 0,
            'optimization_opportunities': 0
        }
    
    def interpret_clusters(self, 
                          data_with_clusters: pd.DataFrame,
                          original_data: pd.DataFrame) -> Dict[str, Any]:
        """
        Основной метод интерпретации кластеров.
        
        Args:
            data_with_clusters: DataFrame с результатами кластеризации
            original_data: Исходные данные для контекстного анализа
            
        Returns:
            Словарь с результатами интерпретации для разных аудиторий
        """
        print("🚀 Запуск интерпретации кластеров пермиссий Tessa...")
        print("=" * 70)
        
        # Шаг 1: Анализ качества кластеризации
        quality_report = self._assess_clustering_quality(data_with_clusters)
        
        # Шаг 2: Определение лучшего метода кластеризации
        best_method = self._determine_best_method(data_with_clusters)
        
        # Шаг 3: Классификация кластеров по типам
        cluster_types = self._classify_cluster_types(
            data_with_clusters, 
            best_method, 
            original_data
        )
        
        # Шаг 4: Сопоставление с организационной структурой
        org_mapping = self._map_to_organization(
            data_with_clusters, 
            best_method, 
            original_data
        )
        
        # Шаг 5: Оценка рисков безопасности
        risk_assessment = self._assess_security_risks(
            data_with_clusters,
            best_method,
            cluster_types,
            original_data
        )
        
        # Шаг 6: Генерация рекомендаций
        recommendations = self._generate_recommendations(
            data_with_clusters,
            best_method,
            cluster_types,
            risk_assessment,
            original_data
        )
        
        # Шаг 7: Формирование отчетов для разных аудиторий
        reports = self._generate_stakeholder_reports(
            quality_report,
            best_method,
            cluster_types,
            org_mapping,
            risk_assessment,
            recommendations
        )
        
        # Шаг 8: Визуализация результатов
        self._create_visualizations(
            data_with_clusters,
            best_method,
            cluster_types,
            risk_assessment
        )
        
        # Шаг 9: Сохранение результатов
        self._save_interpretation_results(reports)
        
        # Шаг 10: Формирование дорожной карты
        roadmap = self._create_optimization_roadmap(recommendations)
        
        print("=" * 70)
        print("✅ Интерпретация кластеров успешно завершена!")
        print(f"📊 Проанализировано кластеров: {self.interpretation_stats['total_clusters']}")
        print(f"⚠️  Выявлено рисковых кластеров: {self.interpretation_stats['risky_clusters']}")
        print(f"🔧 Рекомендаций по оптимизации: {self.interpretation_stats['optimization_opportunities']}")
        
        return {
            'quality_report': quality_report,
            'best_method': best_method,
            'cluster_types': cluster_types,
            'organization_mapping': org_mapping,
            'risk_assessment': risk_assessment,
            'recommendations': recommendations,
            'stakeholder_reports': reports,
            'optimization_roadmap': roadmap
        }
    
    # ВНУТРЕННИЕ МЕТОДЫ ИНТЕРПРЕТАЦИИ
    
    def _assess_clustering_quality(self, data: pd.DataFrame) -> Dict[str, Any]:
        """
        Оценка качества кластеризации по силуэтной оценке.
        
        Методология: Rousseeuw, P.J. (1987) Silhouettes
        """
        print("\n📈 ШАГ 1: Оценка качества кластеризации...")
        
        quality_metrics = {}
        methods = ['hdbscan', 'optics', 'dbscan']
        
        for method in methods:
            silhouette_col = f'{method}_silhouette_vals'
            if silhouette_col in data.columns:
                scores = data[silhouette_col]
                # Исключаем шум (-1) для расчета
                cluster_scores = scores[data[f'{method}_cluster'] >= 0]
                
                quality_metrics[method] = {
                    'mean_silhouette': cluster_scores.mean(),
                    'median_silhouette': cluster_scores.median(),
                    'std_silhouette': cluster_scores.std(),
                    'min_silhouette': cluster_scores.min(),
                    'max_silhouette': cluster_scores.max(),
                    'noise_percentage': (data[f'{method}_cluster'] == -1).mean() * 100,
                    'num_clusters': data[f'{method}_cluster'].nunique() - 1  # исключаем шум
                }
                
                # Интерпретация силуэтной оценки
                mean_score = quality_metrics[method]['mean_silhouette']
                if mean_score > 0.7:
                    quality = "Отличное"
                elif mean_score > 0.5:
                    quality = "Хорошее"
                elif mean_score > 0.25:
                    quality = "Удовлетворительное"
                else:
                    quality = "Слабое"
                
                quality_metrics[method]['interpretation'] = quality
                
                print(f"   - {method.upper()}: {quality} качество (средняя оценка: {mean_score:.3f})")
        
        return quality_metrics
    
    def _determine_best_method(self, data: pd.DataFrame) -> str:
        """
        Определение лучшего метода кластеризации на основе:
        1. Средней силуэтной оценки
        2. Процента шума
        3. Количества кластеров
        """
        print("\n🏆 ШАГ 2: Определение лучшего метода кластеризации...")
        
        methods = ['hdbscan', 'optics', 'dbscan']
        method_scores = {}

        # Определение количества кластеров
        # для использования в нормализации количества кластеров
        # при расчетах взвешенной оценки кластеров
        nums_clusters = {}
        for method in methods:
            nums_clusters[method] = data[f'{method}_cluster'].nunique() - 1
        
        for method in methods:
            silhouette_col = f'{method}_silhouette_vals'
            if silhouette_col in data.columns:
                # Взвешенная оценка метода
                # Rosseeuw P.J. (1987) - автор силуэтного анализа
                # рекомендует использовать медиану
                # для оценки "типичного" качества кластеризации
                median_silhouette = data[silhouette_col].median()
                noise_percent = (data[f'{method}_cluster'] == -1).mean()
                #num_clusters = data[f'{method}_cluster'].nunique() - 1
                
                # Эвристическая формула оценки
                # Больший вес силуэтной оценке, меньший - проценту шума
                score = (0.6 * median_silhouette + 
                        0.3 * (1 - noise_percent) + 
                        0.1 * (nums_clusters[method] / nums_clusters[max(nums_clusters)]))  # нормализуем количество кластеров
                        #0.1 * min(num_clusters / 20, 1))  # нормализуем количество кластеров
                
                method_scores[method] = score
        
        if method_scores:
            best_method = max(method_scores, key=method_scores.get)
            print(f"   ✅ Лучший метод: {best_method.upper()} (взвешенная оценка: {method_scores[best_method]:.3f})")
            return best_method
        
        return 'hdbscan'  # fallback
    
    def _classify_cluster_types(self, 
                               data: pd.DataFrame, 
                               method: str,
                               original_data: pd.DataFrame) -> Dict[int, Dict[str, Any]]:
        """
        Классификация кластеров на типы:
        1. Нормативные
        2. Аномальные
        3. Рисковые
        4. Ошибочные
        5. Уникальные
        6. Привилегированные
        """
        print(f"\n🏷️  ШАГ 3: Классификация кластеров ({method.upper()})...")
        
        cluster_col = f'{method}_cluster'
        silhouette_col = f'{method}_silhouette_vals'
        
        # Исключаем шум (-1)
        valid_clusters = [c for c in data[cluster_col].unique() if c >= 0]
        self.interpretation_stats['total_clusters'] = len(valid_clusters)
        
        cluster_types = {}
        
        for cluster_id in valid_clusters:
            cluster_data = data[data[cluster_col] == cluster_id]
            cluster_size = len(cluster_data)
            total_size = len(data[data[cluster_col] >= 0])
            
            # Базовые метрики
            silhouette_mean = cluster_data[silhouette_col].mean()
            size_ratio = cluster_size / total_size
            
            # Анализ признаков кластера
            feature_analysis = self._analyze_cluster_features(
                cluster_data, 
                original_data
            )
            
            # Определение типа кластера
            cluster_type = self._determine_cluster_type(
                silhouette_mean,
                size_ratio,
                feature_analysis
            )
            
            # Оценка привилегированности
            is_privileged = self._assess_privilege_level(feature_analysis)
            
            cluster_types[cluster_id] = {
                'type': cluster_type,
                'subtype': 'Привилегированный' if is_privileged else cluster_type.value,
                'size': cluster_size,
                'size_percentage': size_ratio * 100,
                'silhouette_score': silhouette_mean,
                'feature_profile': feature_analysis,
                'is_privileged': is_privileged,
                'risk_level': RiskLevel.INFO  # будет уточнено позже
            }
            
            print(f"   - Кластер {cluster_id}: {cluster_type.value} "
                  f"({cluster_size} объектов, {size_ratio:.3%}, силуэт: {silhouette_mean:.3f})")
        
        return cluster_types
    
    def _analyze_cluster_features(self, 
                                 cluster_data: pd.DataFrame,
                                 original_data: pd.DataFrame) -> Dict[str, Any]:
        """
        Анализ признаков кластера для создания профиля.
        """
        profile = {
            'dominant_features': {},
            'unique_combinations': 0,
            'privilege_indicators': [],
            'anomaly_indicators': []
        }
        
        # Анализ категориальных признаков
        categorical_cols = original_data.select_dtypes(include=['object']).columns
        
        for col in categorical_cols[:10]:  # Ограничиваем для производительности
            if col in cluster_data.columns:
                value_counts = cluster_data[col].value_counts()
                if len(value_counts) > 0:
                    dominant_value = value_counts.index[0]
                    dominance_ratio = value_counts.iloc[0] / len(cluster_data)
                    
                    if dominance_ratio > 0.7:  # Явно доминирующее значение
                        profile['dominant_features'][col] = {
                            'value': dominant_value,
                            'ratio': dominance_ratio
                        }
        
        # Анализ привилегий
        privilege_keywords = ['admin', 'root', 'супер', 'полный', 'все']
        for col in categorical_cols:
            if any(keyword in str(col).lower() for keyword in privilege_keywords):
                unique_values = cluster_data[col].nunique()
                if unique_values == 1:  # Все объекты имеют одинаковое значение
                    profile['privilege_indicators'].append(col)
        
        return profile
    
    def _determine_cluster_type(self, 
                               silhouette_score: float,
                               size_ratio: float,
                               feature_analysis: Dict[str, Any]) -> ClusterType:
        """
        Определение типа кластера на основе метрик.
        """
        # Уникальные/маленькие кластеры
        if size_ratio < 0.005:  # Менее 0.5%
            return ClusterType.UNIQUE
        
        # Ошибочные кластеры (низкое качество)
        if silhouette_score < 0.1:
            return ClusterType.ERRONEOUS
        
        # Нормативные кластеры
        if (silhouette_score > self.config.silhouette_threshold and 
            size_ratio > self.config.size_threshold):
            return ClusterType.NORMAL
        
        # Рисковые кластеры (показатели привилегий)
        if len(feature_analysis.get('privilege_indicators', [])) > 0:
            return ClusterType.RISKY
        
        # Аномальные кластеры
        if 0.1 <= silhouette_score <= 0.3:
            return ClusterType.ANOMALOUS
        
        return ClusterType.NORMAL  # По умолчанию
    
    def _assess_privilege_level(self, feature_analysis: Dict[str, Any]) -> bool:
        """
        Оценка уровня привилегий кластера.
        """
        privilege_indicators = feature_analysis.get('privilege_indicators', [])
        return len(privilege_indicators) >= 2  # Два и более индикатора
    
    def _map_to_organization(self,
                            data: pd.DataFrame,
                            method: str,
                            original_data: pd.DataFrame) -> Dict[int, Dict[str, Any]]:
        """
        Сопоставление кластеров с организационной структурой.
        """
        print(f"\n🏢 ШАГ 4: Сопоставление с организационной структурой...")
        
        mapping = {}
        cluster_col = f'{method}_cluster'
        
        # Поиск столбцов, связанных с организацией
        org_columns = self._identify_org_columns(original_data)
        
        for cluster_id in data[cluster_col].unique():
            if cluster_id >= 0:  # Исключаем шум
                cluster_data = data[data[cluster_col] == cluster_id]
                
                org_profile = {}
                for col in org_columns:
                    if col in cluster_data.columns:
                        # Самые частые значения в кластере
                        top_values = cluster_data[col].value_counts().head(3)
                        org_profile[col] = {
                            'values': top_values.index.tolist(),
                            'counts': top_values.values.tolist(),
                            'total': len(cluster_data)
                        }
                
                # Определение предполагаемого отдела/роли
                department, role = self._infer_department_role(org_profile)
                
                mapping[cluster_id] = {
                    'department': department,
                    'role': role,
                    'org_profile': org_profile,
                    'user_count': len(cluster_data)
                }
                
                if department:
                    print(f"   - Кластер {cluster_id}: {department} → {role or 'Не определено'}")
        
        return mapping
    
    def _identify_org_columns(self, data: pd.DataFrame) -> List[str]:
        """
        Идентификация столбцов, связанных с организационной структурой.
        """
        org_keywords = ['отдел', 'департамент', 'роль', 'должность', 'department', 'role', 'team']
        org_columns = []
        
        for col in data.columns:
            col_lower = str(col).lower()
            if any(keyword in col_lower for keyword in org_keywords):
                org_columns.append(col)
        
        return org_columns[:5]  # Ограничиваем до 5 столбцов
    
    def _infer_department_role(self, org_profile: Dict[str, Any]) -> Tuple[str, str]:
        """
        Вывод предполагаемого отдела и роли на основе профиля.
        """
        department = None
        role = None
        
        # Эвристические правила
        for col, profile in org_profile.items():
            col_lower = str(col).lower()
            
            if 'отдел' in col_lower or 'департамент' in col_lower:
                if profile['values']:
                    department = profile['values'][0]
            
            if 'роль' in col_lower or 'должность' in col_lower:
                if profile['values']:
                    role = profile['values'][0]
        
        return department, role
    
    def _assess_security_risks(self,
                              data: pd.DataFrame,
                              method: str,
                              cluster_types: Dict[int, Dict[str, Any]],
                              original_data: pd.DataFrame) -> Dict[int, Dict[str, Any]]:
        """
        Оценка рисков безопасности для каждого кластера.
        """
        print(f"\n⚠️  ШАГ 5: Оценка рисков безопасности...")
        
        risk_assessment = {}
        self.interpretation_stats['risky_clusters'] = 0
        
        cluster_col = f'{method}_cluster'
        
        for cluster_id, cluster_info in cluster_types.items():
            if cluster_id >= 0:
                cluster_data = data[data[cluster_col] == cluster_id]
                
                # Оценка рисков на основе типа и характеристик
                risk_level, risk_factors = self._calculate_risk_level(
                    cluster_info,
                    cluster_data,
                    original_data
                )
                
                risk_assessment[cluster_id] = {
                    'risk_level': risk_level,
                    'risk_factors': risk_factors,
                    'urgency': self._determine_urgency(risk_level, cluster_info),
                    'mitigation_priority': self._calculate_priority(
                        risk_level, 
                        cluster_info['size']
                    )
                }
                
                if risk_level in [RiskLevel.CRITICAL, RiskLevel.HIGH]:
                    self.interpretation_stats['risky_clusters'] += 1
                    print(f"   ⚠️  Кластер {cluster_id}: {risk_level.value} риск "
                          f"({', '.join(risk_factors[:2])})")
        
        return risk_assessment
    
    def _calculate_risk_level(self,
                             cluster_info: Dict[str, Any],
                             cluster_data: pd.DataFrame,
                             original_data: pd.DataFrame) -> Tuple[RiskLevel, List[str]]:
        """
        Расчет уровня риска безопасности.
        """
        risk_factors = []
        risk_score = 0
        
        # Фактор 1: Тип кластера
        if cluster_info['type'] == ClusterType.RISKY:
            risk_score += 3
            risk_factors.append("Рисковый тип доступа")
        
        # Фактор 2: Привилегированность
        if cluster_info.get('is_privileged', False):
            risk_score += 2
            risk_factors.append("Высокий уровень привилегий")
        
        # Фактор 3: Размер кластера (больше пользователей = выше риск)
        if cluster_info['size_percentage'] > 5:  # Больше 5%
            risk_score += 1
            risk_factors.append("Большое количество пользователей")
        
        # Фактор 4: Качество кластеризации (низкое качество = выше риск)
        if cluster_info['silhouette_score'] < 0.2:
            risk_score += 2
            risk_factors.append("Низкая определенность паттерна")
        
        # Фактор 5: Чувствительные операции
        sensitive_ops = self._detect_sensitive_operations(cluster_data, original_data)
        if sensitive_ops:
            risk_score += len(sensitive_ops)
            risk_factors.append(f"Чувствительные операции: {', '.join(sensitive_ops[:3])}")
        
        # Определение уровня риска
        if risk_score >= 5:
            return RiskLevel.CRITICAL, risk_factors
        elif risk_score >= 3:
            return RiskLevel.HIGH, risk_factors
        elif risk_score >= 2:
            return RiskLevel.MEDIUM, risk_factors
        elif risk_score >= 1:
            return RiskLevel.LOW, risk_factors
        else:
            return RiskLevel.INFO, ["Низкий риск"]
    
    def _detect_sensitive_operations(self, 
                                    cluster_data: pd.DataFrame,
                                    original_data: pd.DataFrame) -> List[str]:
        """
        Обнаружение чувствительных операций в кластере.
        """
        sensitive_ops = []
        
        # Поиск столбцов с операциями
        operation_cols = [col for col in original_data.columns 
                         if 'операц' in str(col).lower() or 'действ' in str(col).lower()]
        
        for col in operation_cols[:3]:  # Ограничиваем для производительности
            if col in cluster_data.columns:
                unique_ops = cluster_data[col].unique()
                for op in unique_ops:
                    op_str = str(op).lower()
                    # Проверка на чувствительные операции
                    if any(sensitive in op_str 
                          for sensitive in self.config.sensitive_operations):
                        sensitive_ops.append(str(op))
        
        return list(set(sensitive_ops))[:5]  # Уникальные, до 5 операций
    
    def _determine_urgency(self, 
                          risk_level: RiskLevel, 
                          cluster_info: Dict[str, Any]) -> str:
        """
        Определение срочности действий.
        """
        urgency_map = {
            RiskLevel.CRITICAL: "Немедленно (1-3 дня)",
            RiskLevel.HIGH: "Срочно (1 неделя)",
            RiskLevel.MEDIUM: "В течение месяца",
            RiskLevel.LOW: "Плановая оптимизация",
            RiskLevel.INFO: "Мониторинг"
        }
        return urgency_map.get(risk_level, "Мониторинг")
    
    def _calculate_priority(self, risk_level: RiskLevel, size: int) -> int:
        """
        Расчет приоритета для дорожной карты.
        """
        priority_map = {
            RiskLevel.CRITICAL: 0,
            RiskLevel.HIGH: 1,
            RiskLevel.MEDIUM: 2,
            RiskLevel.LOW: 3,
            RiskLevel.INFO: 4
        }
        return priority_map.get(risk_level, 4)
    
    def _generate_recommendations(self,
                                 data: pd.DataFrame,
                                 method: str,
                                 cluster_types: Dict[int, Dict[str, Any]],
                                 risk_assessment: Dict[int, Dict[str, Any]],
                                 original_data: pd.DataFrame) -> Dict[str, List[Dict[str, Any]]]:
        """
        Генерация рекомендаций для разных стейкхолдеров.
        """
        print(f"\n🔧 ШАГ 6: Генерация рекомендаций...")
        
        recommendations = {
            'leadership': [],      # Руководство
            'business_analysts': [], # Бизнес-аналитики
            'system_admins': [],   # Администраторы
            'security': [],        # Специалисты безопасности
            'data_analysts': []    # Аналитики данных
        }
        
        cluster_col = f'{method}_cluster'
        
        for cluster_id, cluster_info in cluster_types.items():
            if cluster_id >= 0:
                cluster_data = data[data[cluster_col] == cluster_id]
                risk_info = risk_assessment.get(cluster_id, {})
                
                # Генерация рекомендаций для каждой аудитории
                self._add_leadership_recommendations(
                    recommendations, cluster_id, cluster_info, risk_info
                )
                
                self._add_business_analyst_recommendations(
                    recommendations, cluster_id, cluster_info, risk_info, original_data
                )
                
                self._add_system_admin_recommendations(
                    recommendations, cluster_id, cluster_info, risk_info, cluster_data
                )
                
                self._add_security_recommendations(
                    recommendations, cluster_id, cluster_info, risk_info, cluster_data
                )
                
                self._add_data_analyst_recommendations(
                    recommendations, cluster_id, cluster_info, risk_info
                )
        
        # Подсчет рекомендаций
        total_recs = sum(len(recs) for recs in recommendations.values())
        self.interpretation_stats['optimization_opportunities'] = total_recs
        
        print(f"   📋 Сгенерировано рекомендаций: {total_recs}")
        for audience, recs in recommendations.items():
            if recs:
                print(f"     - {audience}: {len(recs)} рекомендаций")
        
        return recommendations
    
    def _add_leadership_recommendations(self,
                                       recommendations: Dict[str, List],
                                       cluster_id: int,
                                       cluster_info: Dict[str, Any],
                                       risk_info: Dict[str, Any]):
        """Рекомендации для руководства."""
        if risk_info.get('risk_level') in [RiskLevel.CRITICAL, RiskLevel.HIGH]:
            recommendations['leadership'].append({
                'cluster': cluster_id,
                'priority': 'Высокий',
                'action': f"Требуется внимание к кластеру {cluster_id}",
                'reason': f"{risk_info['risk_level'].value} риск: {', '.join(risk_info['risk_factors'][:2])}",
                'impact': f"{cluster_info['size']} пользователей ({cluster_info['size_percentage']:.3f}%)",
                'timeline': risk_info.get('urgency', 'Не определено')
            })
    
    def _add_business_analyst_recommendations(self,
                                             recommendations: Dict[str, List],
                                             cluster_id: int,
                                             cluster_info: Dict[str, Any],
                                             risk_info: Dict[str, Any],
                                             original_data: pd.DataFrame):
        """Рекомендации для бизнес-аналитиков."""
        if cluster_info['type'] == ClusterType.NORMAL and cluster_info['size_percentage'] > 2:
            recommendations['business_analysts'].append({
                'cluster': cluster_id,
                'action': "Стандартизировать в роль",
                'reason': f"Стабильный паттерн ({cluster_info['size']} пользователей)",
                'suggested_role_name': f"Role_Cluster_{cluster_id}",
                'benefit': "Упрощение управления доступом"
            })
    
    def _add_system_admin_recommendations(self,
                                         recommendations: Dict[str, List],
                                         cluster_id: int,
                                         cluster_info: Dict[str, Any],
                                         risk_info: Dict[str, Any],
                                         cluster_data: pd.DataFrame):
        """Рекомендации для системных администраторов."""
        if cluster_info['type'] == ClusterType.RISKY or cluster_info.get('is_privileged', False):
            recommendations['system_admins'].append({
                'cluster': cluster_id,
                'action': "Проверить и оптимизировать права",
                'reason': f"{cluster_info['subtype']} доступ",
                'users_count': cluster_info['size'],
                'suggested_actions': [
                    "Аудит назначенных прав",
                    "Применить принцип наименьших привилегий",
                    "Документировать исключения"
                ]
            })
    
    def _add_security_recommendations(self,
                                     recommendations: Dict[str, List],
                                     cluster_id: int,
                                     cluster_info: Dict[str, Any],
                                     risk_info: Dict[str, Any],
                                     cluster_data: pd.DataFrame):
        """Рекомендации для специалистов по безопасности."""
        if risk_info.get('risk_level') in [RiskLevel.CRITICAL, RiskLevel.HIGH]:
            recommendations['security'].append({
                'cluster': cluster_id,
                'threat_level': risk_info['risk_level'].value,
                'action': "Немедленный аудит безопасности",
                'risk_factors': risk_info['risk_factors'],
                'users_affected': cluster_info['size'],
                'mitigation': [
                    "Временное ограничение прав",
                    "Аудит действий пользователей",
                    "Уведомление ответственных лиц"
                ]
            })
    
    def _add_data_analyst_recommendations(self,
                                         recommendations: Dict[str, List],
                                         cluster_id: int,
                                         cluster_info: Dict[str, Any],
                                         risk_info: Dict[str, Any]):
        """Рекомендации для аналитиков данных."""
        if cluster_info['silhouette_score'] < 0.3:
            recommendations['data_analysts'].append({
                'cluster': cluster_id,
                'action': "Улучшить качество данных",
                'reason': f"Низкая силуэтная оценка ({cluster_info['silhouette_score']:.3f})",
                'suggestions': [
                    "Проверить полноту данных",
                    "Уточнить категоризацию признаков",
                    "Рассмотреть дополнительные признаки"
                ]
            })
    
    def _generate_stakeholder_reports(self,
                                     quality_report: Dict[str, Any],
                                     best_method: str,
                                     cluster_types: Dict[int, Dict[str, Any]],
                                     org_mapping: Dict[int, Dict[str, Any]],
                                     risk_assessment: Dict[int, Dict[str, Any]],
                                     recommendations: Dict[str, List]) -> Dict[str, str]:
        """
        Формирование отчетов для разных аудиторий.
        """
        print(f"\n📄 ШАГ 7: Формирование отчетов для стейкхолдеров...")
        
        reports = {}
        
        # Отчет для руководства (краткий, стратегический)
        reports['leadership'] = self._create_leadership_report(
            quality_report, best_method, cluster_types, risk_assessment
        )
        
        # Отчет для бизнес-аналитиков
        reports['business_analysts'] = self._create_business_analyst_report(
            cluster_types, org_mapping, recommendations
        )
        
        # Отчет для системных администраторов
        reports['system_admins'] = self._create_system_admin_report(
            cluster_types, risk_assessment, recommendations
        )
        
        # Отчет для специалистов безопасности
        reports['security'] = self._create_security_report(
            risk_assessment, recommendations
        )
        
        # Отчет для аналитиков данных
        reports['data_analysts'] = self._create_data_analyst_report(
            quality_report, best_method, recommendations
        )
        
        print("   ✅ Отчеты сформированы для 5 аудиторий")
        return reports
    
    def _create_leadership_report(self, quality_report, best_method, cluster_types, risk_assessment):
        """Создание отчета для руководства."""
        critical_risks = sum(1 for risk in risk_assessment.values() 
                            if risk['risk_level'] in [RiskLevel.CRITICAL, RiskLevel.HIGH])
        
        report = f"""
# 📊 ОТЧЕТ ДЛЯ РУКОВОДСТВА
## Анализ модели доступа Tessa

### Ключевые метрики
- **Лучший метод анализа**: {best_method.upper()}
- **Всего кластеров**: {len(cluster_types)}
- **Критические риски**: {critical_risks}
- **Оптимизированные паттерны**: {sum(1 for c in cluster_types.values() if c['type'] == ClusterType.NORMAL)}

### Основные выводы
1. **Безопасность**: {critical_risks} критических/высоких рисков требуют внимания
2. **Эффективность**: {len([c for c in cluster_types.values() if c['size_percentage'] > 2])} крупных кластеров для стандартизации
3. **Управляемость**: {len(cluster_types)} паттернов вместо тысяч индивидуальных назначений

### Рекомендуемые действия
1. **Немедленно**: Аудит {critical_risks} рисковых кластеров
2. **Краткосрочно**: Стандартизация крупных паттернов
3. **Долгосрочно**: Внедрение RBAC для 80% пользователей

### Бизнес-ценность
- **Снижение рисков**: На {(critical_risks * 20):.2f}% (оценка)
- **Экономия времени администрирования**: До 30%
- **Соответствие требованиям**: Улучшение контроля доступа
"""
        return report
    
    def _create_business_analyst_report(self, cluster_types, org_mapping, recommendations):
        """Создание отчета для бизнес-аналитиков."""
        normal_clusters = [c for c in cluster_types.values() 
                          if c['type'] == ClusterType.NORMAL and c['size_percentage'] > 2]
        
        report = f"""
# 📈 ОТЧЕТ ДЛЯ БИЗНЕС-АНАЛИТИКОВ
## Оптимизация ролевой модели Tessa

### Обнаруженные паттерны
Всего {len(normal_clusters)} стабильных паттернов для стандартизации:

"""
        for cluster_id, info in list(cluster_types.items())[:10]:  # Первые 10
            org_info = org_mapping.get(cluster_id, {})
            report += f"**Кластер {cluster_id}**: {info['size']} пользователей ({info['size_percentage']:.3f}%)\n"
            if org_info.get('department'):
                report += f"  - Предполагаемый отдел: {org_info['department']}\n"
            report += f"  - Тип: {info['subtype']}\n"
            report += f"  - Качество: {info['silhouette_score']:.3f}\n\n"
        
        report += f"""
### Рекомендации по стандартизации
{len(recommendations.get('business_analysts', []))} ролей для создания:

"""
        for rec in recommendations.get('business_analysts', [])[:5]:
            report += f"- **{rec['suggested_role_name']}**: {rec['reason']}\n"
        
        return report
    
    def _create_system_admin_report(self, cluster_types, risk_assessment, recommendations):
        """Создание отчета для системных администраторов."""
        risky_clusters = [c for c in cluster_types.values() 
                         if c['type'] == ClusterType.RISKY or c.get('is_privileged', False)]
        
        report = f"""
# 🔧 ОТЧЕТ ДЛЯ СИСТЕМНЫХ АДМИНИСТРАТОРОВ
## Практические действия по оптимизации доступа

### Критические кластеры для аудита
Всего {len(risky_clusters)} кластеров требуют внимания:

"""
        for cluster_id, info in list(cluster_types.items()):
            if info['type'] == ClusterType.RISKY or info.get('is_privileged', False):
                risk_info = risk_assessment.get(cluster_id, {})
                report += f"**Кластер {cluster_id}** ({info['size']} пользователей):\n"
                report += f"  - Риск: {risk_info.get('risk_level', RiskLevel.INFO).value}\n"
                report += f"  - Срочность: {risk_info.get('urgency', 'Не определено')}\n"
                report += f"  - Действия: Проверить права, применить PoLP\n\n"
        
        report += f"""
### Конкретные действия
{len(recommendations.get('system_admins', []))} задач для выполнения:

"""
        for rec in recommendations.get('system_admins', [])[:5]:
            report += f"**Задача**: {rec['action']}\n"
            report += f"  - Причина: {rec['reason']}\n"
            report += f"  - Пользователей: {rec['users_count']}\n"
            report += f"  - Шаги:\n"
            for action in rec['suggested_actions']:
                report += f"    - {action}\n"
            report += "\n"
        
        return report
    
    def _create_security_report(self, risk_assessment, recommendations):
        """Создание отчета для специалистов по безопасности."""
        critical_risks = [r for r in risk_assessment.values() 
                         if r['risk_level'] in [RiskLevel.CRITICAL, RiskLevel.HIGH]]
        
        report = f"""
# 🔒 ОТЧЕТ ДЛЯ СПЕЦИАЛИСТОВ БЕЗОПАСНОСТИ
## Анализ рисков модели доступа Tessa

### Уровни угроз
- **Критических рисков**: {len([r for r in critical_risks if r['risk_level'] == RiskLevel.CRITICAL])}
- **Высоких рисков**: {len([r for r in critical_risks if r['risk_level'] == RiskLevel.HIGH])}
- **Всего рисковых кластеров**: {len(critical_risks)}

### Детализация рисков
"""
        for cluster_id, risk_info in list(risk_assessment.items()):
            if risk_info['risk_level'] in [RiskLevel.CRITICAL, RiskLevel.HIGH]:
                report += f"**Кластер {cluster_id}**: {risk_info['risk_level'].value}\n"
                report += f"  - Факторы: {', '.join(risk_info['risk_factors'][:3])}\n"
                report += f"  - Приоритет: P{risk_info['mitigation_priority']}\n"
                report += f"  - Меры: {risk_info.get('urgency', 'Не определено')}\n\n"
        
        report += f"""
### Меры по смягчению
{len(recommendations.get('security', []))} неотложных действий:

"""
        for rec in recommendations.get('security', [])[:5]:
            report += f"**Кластер {rec['cluster']}. {rec['action']}** (Уровень: {rec['threat_level']})\n"
            report += f"  - Факторы риска: {', '.join(rec['risk_factors'][:3])}\n"
            report += f"  - Меры:\n"
            for mitigation in rec['mitigation']:
                report += f"    - {mitigation}\n"
            report += "\n"
        
        return report
    
    def _create_data_analyst_report(self, quality_report, best_method, recommendations):
        """Создание отчета для аналитиков данных."""
        method_quality = quality_report.get(best_method, {})
        
        report = f"""
# 📊 ОТЧЕТ ДЛЯ АНАЛИТИКОВ ДАННЫХ
## Методологический анализ кластеризации

### Качество методов кластеризации
**Лучший метод**: {best_method.upper()}
- Средняя силуэтная оценка: {method_quality.get('mean_silhouette', 0):.3f}
- Качество интерпретации: {method_quality.get('interpretation', 'Не определено')}
- Процент шума: {method_quality.get('noise_percentage', 0):.3f}%
- Количество кластеров: {method_quality.get('num_clusters', 0)}

### Сравнение методов
"""
        for method, metrics in quality_report.items():
            report += f"**{method.upper()}**:\n"
            report += f"  - Силуэт: {metrics.get('mean_silhouette', 0):.3f}\n"
            report += f"  - Качество: {metrics.get('interpretation', 'Не определено')}\n"
            report += f"  - Кластеров: {metrics.get('num_clusters', 0)}\n\n"
        
        report += f"""
### Рекомендации по улучшению данных
{len(recommendations.get('data_analysts', []))} предложений:

"""
        for rec in recommendations.get('data_analysts', []):
            report += f"- **Кластер {rec['cluster']}**. {rec['action']}: {rec['reason']}\n"
            for suggestion in rec['suggestions']:
                report += f"  - {suggestion}\n"
        
        return report
    
    def _create_visualizations(self,
                              data: pd.DataFrame,
                              method: str,
                              cluster_types: Dict[int, Dict[str, Any]],
                              risk_assessment: Dict[int, Dict[str, Any]]):
        """
        Создание визуализаций для разных аудиторий.
        """
        print(f"\n📊 ШАГ 8: Создание визуализаций...")
        
        try:
            # 1. Heatmap силуэтных оценок
            self._plot_silhouette_heatmap(data, method)
            
            # 2. Распределение кластеров по типам
            self._plot_cluster_type_distribution(cluster_types)
            
            # 3. Карта рисков
            self._plot_risk_map(risk_assessment, cluster_types)
            
            # 4. Распределение размеров кластеров
            self._plot_cluster_size_distribution(cluster_types)
            
            print("   ✅ Создано 4 типа визуализаций")
            
        except Exception as e:
            print(f"   ⚠️  Ошибка при создании визуализаций: {e}")
    
    def _plot_silhouette_heatmap(self, data: pd.DataFrame, method: str):
        """Heatmap силуэтных оценок."""
        plt.figure(figsize=(12, 8))
        
        # Подготовка данных
        silhouette_col = f'{method}_silhouette_vals'
        cluster_col = f'{method}_cluster'
        
        # Исключаем шум
        plot_data = data[data[cluster_col] >= 0].copy()
        
        # Создание heatmap
        pivot_table = pd.pivot_table(
            plot_data,
            values=silhouette_col,
            index=cluster_col,
            aggfunc='mean'
        ).sort_values(by=silhouette_col, ascending=False)
        
        sns.heatmap(pivot_table, annot=True, cmap='RdYlGn', center=0.5)
        plt.title(f'Силуэтные оценки кластеров ({method.upper()})', fontsize=14)
        plt.xlabel('Силуэтная оценка')
        plt.ylabel('Номер кластера')
        
        # Сохранение
        plt.savefig('silhouette_heatmap.png', dpi=150, bbox_inches='tight')
        plt.close()
    
    def _plot_cluster_type_distribution(self, cluster_types: Dict[int, Dict[str, Any]]):
        """Распределение кластеров по типам."""
        plt.figure(figsize=(10, 6))
        
        # Подсчет по типам
        type_counts = {}
        for info in cluster_types.values():
            type_name = info['subtype']
            type_counts[type_name] = type_counts.get(type_name, 0) + 1
        
        # Создание графика
        colors = ['green', 'yellow', 'orange', 'red', 'blue', 'purple']
        plt.pie(type_counts.values(), labels=type_counts.keys(), 
                autopct='%1.1f%%', colors=colors[:len(type_counts)])
        plt.title('Распределение кластеров по типам', fontsize=14)
        
        # Сохранение
        plt.savefig('cluster_type_distribution.png', dpi=150, bbox_inches='tight')
        plt.close()
    
    def _plot_risk_map(self, risk_assessment, cluster_types):
        """Карта рисков кластеров."""
        plt.figure(figsize=(14, 8))
        
        # Подготовка данных
        clusters = []
        sizes = []
        risks = []
        
        for cluster_id, info in cluster_types.items():
            risk_info = risk_assessment.get(cluster_id, {})
            if risk_info:
                clusters.append(cluster_id)
                sizes.append(info['size'])
                
                # Преобразование уровня риска в числовой
                risk_map = {
                    RiskLevel.CRITICAL: 4,
                    RiskLevel.HIGH: 3,
                    RiskLevel.MEDIUM: 2,
                    RiskLevel.LOW: 1,
                    RiskLevel.INFO: 0
                }
                risks.append(risk_map.get(risk_info['risk_level'], 0))
        
        # Создание scatter plot
        scatter = plt.scatter(clusters, sizes, c=risks, cmap='RdYlGn_r', 
                             s=100, alpha=0.7, edgecolors='black')
        
        plt.colorbar(scatter, label='Уровень риска (0-4)')
        plt.xlabel('Номер кластера')
        plt.ylabel('Размер кластера (количество объектов)')
        plt.title('Карта рисков кластеров', fontsize=14)
        plt.grid(True, alpha=0.3)
        
        # Сохранение
        plt.savefig('risk_map.png', dpi=150, bbox_inches='tight')
        plt.close()
    
    def _plot_cluster_size_distribution(self, cluster_types):
        """Распределение размеров кластеров."""
        plt.figure(figsize=(12, 6))
        
        sizes = [info['size'] for info in cluster_types.values()]
        
        plt.hist(sizes, bins=20, edgecolor='black', alpha=0.7)
        plt.xlabel('Размер кластера (количество объектов)')
        plt.ylabel('Количество кластеров')
        plt.title('Распределение размеров кластеров', fontsize=14)
        plt.grid(True, alpha=0.3)
        
        # Добавление вертикальной линии для медианы
        median_size = np.median(sizes)
        plt.axvline(median_size, color='red', linestyle='--', 
                   label=f'Медиана: {median_size:.0f}')
        plt.legend()
        
        # Сохранение
        plt.savefig('cluster_size_distribution.png', dpi=150, bbox_inches='tight')
        plt.close()
    
    def _save_interpretation_results(self, reports: Dict[str, str]):
        """
        Сохранение результатов интерпретации.
        """
        print(f"\n💾 ШАГ 9: Сохранение результатов...")
        
        # Сохранение отчетов в файлы
        for audience, report in reports.items():
            filename = f"report_{audience}.md"
            with open(filename, 'w', encoding='utf-8') as f:
                f.write(report)
            print(f"   📄 Отчет для {audience}: {filename}")
        
        # Сохранение структурированных данных
        results = {
            'statistics': self.interpretation_stats,
            'config': self.config.__dict__,
            'timestamp': pd.Timestamp.now().isoformat()
        }
        
        with open('interpretation_summary.json', 'w', encoding='utf-8') as f:
            json.dump(results, f, ensure_ascii=False, indent=2)
        
        print("   💾 Итоговый файл: interpretation_summary.json")
    
    def _create_optimization_roadmap(self, 
                                    recommendations: Dict[str, List]) -> Dict[str, Any]:
        """
        Создание дорожной карты оптимизации.
        """
        print(f"\n🗺️  ШАГ 10: Формирование дорожной карты оптимизации...")
        
        roadmap = {
            'immediate': [],   # 1-3 дня
            'short_term': [],  # 1 неделя
            'medium_term': [], # 1 месяц
            'long_term': []    # 3-6 месяцев
        }
        
        # Распределение рекомендаций по срокам
        for audience, recs in recommendations.items():
            for rec in recs:
                # Определение срока на основе приоритета
                if 'срочн' in str(rec.get('action', '')).lower() or 'немед' in str(rec.get('action', '')).lower():
                    roadmap['immediate'].append({
                        'audience': audience,
                        'action': rec.get('action', ''),
                        'cluster': rec.get('cluster', 'N/A'),
                        'reason': rec.get('reason', '')
                    })
                elif 'недел' in str(rec.get('timeline', '')).lower() if 'timeline' in rec else False:
                    roadmap['short_term'].append({
                        'audience': audience,
                        'action': rec.get('action', ''),
                        'cluster': rec.get('cluster', 'N/A'),
                        'reason': rec.get('reason', '')
                    })
                elif 'месяц' in str(rec.get('timeline', '')).lower() if 'timeline' in rec else False:
                    roadmap['medium_term'].append({
                        'audience': audience,
                        'action': rec.get('action', ''),
                        'cluster': rec.get('cluster', 'N/A'),
                        'reason': rec.get('reason', '')
                    })
                else:
                    roadmap['long_term'].append({
                        'audience': audience,
                        'action': rec.get('action', ''),
                        'cluster': rec.get('cluster', 'N/A'),
                        'reason': rec.get('reason', '')
                    })
        
        # Создание текстовой дорожной карты
        roadmap_text = f"""
# 🗺️ ДОРОЖНАЯ КАРТА ОПТИМИЗАЦИИ МОДЕЛИ ДОСТУПА TESSA

## Немедленные действия (1-3 дня)
{len(roadmap['immediate'])} задач:
"""
        for task in roadmap['immediate'][:5]:
            roadmap_text += f"- **{task['action']}** (Кластер {task['cluster']})\n"
        
        roadmap_text += f"""
## Краткосрочные задачи (1 неделя)
{len(roadmap['short_term'])} задач:
"""
        for task in roadmap['short_term'][:5]:
            roadmap_text += f"- {task['action']}\n"
        
        roadmap_text += f"""
## Среднесрочные задачи (1 месяц)
{len(roadmap['medium_term'])} задач:
"""
        for task in roadmap['medium_term'][:5]:
            roadmap_text += f"- {task['action']}\n"
        
        roadmap_text += f"""
## Долгосрочные улучшения (3-6 месяцев)
{len(roadmap['long_term'])} задач:
"""
        for task in roadmap['long_term'][:5]:
            roadmap_text += f"- {task['action']}\n"
        
        roadmap_text += f"""
### Итоговые метрики
- Всего задач: {sum(len(tasks) for tasks in roadmap.values())}
- Затронуто кластеров: {len(set(task['cluster'] for tasks in roadmap.values() for task in tasks if task['cluster'] != 'N/A'))}
- Аудитории: {len(set(task['audience'] for tasks in roadmap.values() for task in tasks))}
"""
        
        # Сохранение дорожной карты
        with open('optimization_roadmap.md', 'w', encoding='utf-8') as f:
            f.write(roadmap_text)
        
        print(f"   ✅ Дорожная карта сохранена: optimization_roadmap.md")
        print(f"   📋 Задач по срокам:")
        print(f"     - Немедленно: {len(roadmap['immediate'])}")
        print(f"     - Краткосрочно: {len(roadmap['short_term'])}")
        print(f"     - Среднесрочно: {len(roadmap['medium_term'])}")
        print(f"     - Долгосрочно: {len(roadmap['long_term'])}")
        
        return roadmap

# УТИЛИТЫ И ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ

def create_executive_summary(interpretation_results: Dict[str, Any]) -> str:
    """
    Создание краткого резюме для руководства.
    
    Args:
        interpretation_results: Результаты интерпретации
        
    Returns:
        Краткое резюме в формате Markdown
    """
    quality = interpretation_results.get('quality_report', {})
    best_method = interpretation_results.get('best_method', 'N/A')
    cluster_types = interpretation_results.get('cluster_types', {})
    risk_assessment = interpretation_results.get('risk_assessment', {})
    
    # Подсчет критических рисков
    critical_risks = sum(1 for r in risk_assessment.values() 
                        if r.get('risk_level') in [RiskLevel.CRITICAL, RiskLevel.HIGH])
    
    # Подсчет нормальных кластеров
    normal_clusters = sum(1 for c in cluster_types.values() 
                         if c.get('type') == ClusterType.NORMAL)
    
    summary = f"""
# 🎯 КРАТКОЕ РЕЗЮМЕ ДЛЯ РУКОВОДСТВА

## Основные выводы анализа модели доступа Tessa

### 📊 **Статистика анализа**
- **Метод анализа**: {best_method.upper()} (наиболее точный)
- **Всего кластеров**: {len(cluster_types)}
- **Нормальных паттернов**: {normal_clusters} ({normal_clusters/len(cluster_types)*100:.0f}%)
- **Критических рисков**: {critical_risks}

### ⚠️ **Ключевые риски безопасности**
"""
    
    # Добавление топ-3 рисков
    high_risks = []
    for cluster_id, risk_info in risk_assessment.items():
        if risk_info.get('risk_level') in [RiskLevel.CRITICAL, RiskLevel.HIGH]:
            high_risks.append((cluster_id, risk_info))
    
    high_risks.sort(key=lambda x: 4 if x[1]['risk_level'] == RiskLevel.CRITICAL else 3, reverse=True)
    
    for i, (cluster_id, risk_info) in enumerate(high_risks[:3], 1):
        cluster_info = cluster_types.get(cluster_id, {})
        summary += f"{i}. **Кластер {cluster_id}** ({risk_info['risk_level'].value}): "
        summary += f"{cluster_info.get('size', 0)} пользователей, "
        summary += f"факторы: {', '.join(risk_info.get('risk_factors', ['Не определены'])[:2])}\n"
    
    summary += f"""
### 🔧 **Возможности оптимизации**
- **Стандартизация ролей**: {normal_clusters} паттернов для формализации
- **Снижение рисков**: {critical_risks} кластеров для аудита
- **Экономия времени администрирования**: До 30% за счет стандартизации

### 🎯 **Рекомендуемые действия**
1. **Немедленно**: Аудит {critical_risks} критических кластеров
2. **В течение недели**: Стандартизация {min(5, normal_clusters)} основных ролей
3. **В течение месяца**: Внедрение RBAC для 80% пользователей

### 📈 **Ожидаемая бизнес-ценность**
- **Повышение безопасности**: Снижение рисков на {critical_risks * 15:.3f}%
- **Эффективность администрирования**: Сокращение времени на управление доступом
- **Соответствие требованиям**: Улучшение аудита и контроля
"""
    
    return summary

def validate_interpretation_input(data_with_clusters: pd.DataFrame) -> bool:
    """
    Валидация входных данных для интерпретации.
    
    Args:
        data_with_clusters: DataFrame с результатами кластеризации
        
    Returns:
        True если данные валидны, иначе False
    """
    required_columns = [
        'hdbscan_cluster', 'hdbscan_silhouette_vals',
        'optics_cluster', 'optics_silhouette_vals', 
        'dbscan_cluster', 'dbscan_silhouette_vals'
    ]
    
    missing_columns = [col for col in required_columns 
                      if col not in data_with_clusters.columns]
    
    if missing_columns:
        print(f"⚠️  Внимание: отсутствуют необходимые столбцы: {missing_columns}")
        return False
    
    # Проверка наличия данных
    if len(data_with_clusters) == 0:
        print("⚠️  Внимание: DataFrame пуст")
        return False
    
    # Проверка диапазона силуэтных оценок
    for method in ['hdbscan', 'optics', 'dbscan']:
        silhouette_col = f'{method}_silhouette_vals'
        if silhouette_col in data_with_clusters.columns:
            min_val = data_with_clusters[silhouette_col].min()
            max_val = data_with_clusters[silhouette_col].max()
            if min_val < -1 or max_val > 1:
                print(f"⚠️  Внимание: {silhouette_col} вне диапазона [-1, 1]")
                return False
    
    return True