# Загрузка и подготовка данных
data = pd.read_csv('df_permission.csv', encoding='utf-8-sig', sep=';')

print('Анализ данных:')
print(f'Размер: {data.shape}')
data.head(3)

# Преобразуем все в строки и заполняем пропуски
data = data.astype(str).fillna('Unknown')

# Убираем логически не нужные поля
#data = data.drop(['rule_id', 'rule_name', 'role_id', 'document_type_id', 'condition'], axis=1)

# Удаляем полные дубликаты объектов
data = data.drop_duplicates()

print(data.info())
print()
display(data.describe())
print()
data.head(5)

# Анализ уникальных значений
print("Уникальные значения по полям:")
for col in data.columns:
    unique_count = data[col].nunique()
    print(f"{col}: {unique_count} уникальных значений")

# Упрощенное кодирование категориальных признаков
def simple_category_encoding(data):
    """Упрощенное кодирование категориальных признаков"""
    encoded_data = pd.DataFrame()
    
    for col in data.columns:
        unique_count = data[col].nunique()
        
        if unique_count <= 20:
            # One-Hot для малого количества категорий
            dummies = pd.get_dummies(data[col], prefix=col)
            encoded_data = pd.concat([encoded_data, dummies], axis=1)
        else:
            # Frequency encoding для большого количества категорий
            freq_map = data[col].value_counts().to_dict()
            encoded_data[col] = data[col].map(freq_map)
    
    return encoded_data

print("Кодирование признаков...")
encoded_data = simple_category_encoding(data)
print(f"После кодирования: {encoded_data.shape} признаков")
encoded_data.head(5)

# Стандартизация
scaler = StandardScaler()
scaled_data = scaler.fit_transform(encoded_data)

print('Размерность:', scaled_data.shape)
scaled_data

# Уменьшение размерности с проверкой
if scaled_data.shape[1] > 2:
    # Используем PCA только если много признаков
    pca = PCA(n_components=0.9)  # 90% дисперсии
    reduced_data = pca.fit_transform(scaled_data)
    print(f"После PCA: {reduced_data.shape[1]} компонент")
else:
    reduced_data = scaled_data
    print("PCA не применен - мало признаков")

print('Размерность:', reduced_data.shape)
reduced_data

# Аналитический подбор параметров DBSCAN на основе статистики расстояний
def analytical_dbscan_params(X, auto_min_samples=True):
    """
    Аналитический подбор параметров DBSCAN на основе статистики расстояний
    """
    n_samples, n_features = X.shape
    
    # Автоматический подбор min_samples
    # Эвристика: min_samples = 2 * размерность данных
    min_samples = max(2, 2 * n_features)
    # Корректировка для больших наборов данных
    if auto_min_samples & n_samples > 1000:
        min_samples = min(min_samples, 20)
    
    # Анализ распределения расстояний до k-го соседа
    k = min_samples
    nbrs = NearestNeighbors(n_neighbors=k)
    nbrs.fit(X)
    distances, indices = nbrs.kneighbors(X)
    
    # Берем расстояние до k-го соседа (последний в массиве)
    k_distances = distances[:, k-1]
    
    # Статистический анализ для определения eps
    # Метод 1: Анализ квантилей и выбросов
    # (наиболее устойчив к выбросам и подходит к любому распределению)
    Q1 = np.percentile(k_distances, 25)
    Q3 = np.percentile(k_distances, 75)
    IQR = Q3 - Q1
    standard_method = Q3 + 1.5 * IQR

    # Метод 2: Анализ стандартного отклонения от среднего
    # (наименее устойчив к выбросам, подходит только к стандартному распределению)
    std_near_mean = np.mean(k_distances) + 1.5 * np.std(k_distances)
    
    # Метод 3: Поиск точки перегиба в распределении
    # (колено в распределении)
    sorted_distances = np.sort(k_distances)
    gradients = np.gradient(sorted_distances)
    
    # Находим точку максимального изменения градиента
    # (вторая производная)
    inflection_idx = np.argmax(np.abs(np.gradient(gradients)))
    eps_inflection = sorted_distances[inflection_idx]
    
    # Метод 4: Адаптивный порог на основе статистики
    eps_adaptive = np.percentile(k_distances, 85)  # 85-й перцентиль
    
    # Комбинированный подход
    eps_candidates = [
        standard_method,  # Стандартный метод выбросов через квантили
        std_near_mean, # Метод с использованием стандартного отклонения от среднего
        eps_inflection, # 
        eps_adaptive
    ]
    
    # Выбираем наиболее стабильное значение
    #optimal_eps = np.median(eps_candidates) # Рискованный вариант
    optimal_eps = np.min(eps_candidates) # Консервативный вариант (учитывает все подходы)
    
    # Визуализация для валидации
    plt.figure(figsize=(12, 4))
    
    plt.subplot(1, 2, 1)
    plt.hist(k_distances, bins=50, alpha=0.7, edgecolor='black')
    plt.axvline(optimal_eps, color='red', linestyle='--', 
                label=f'Optimal eps: {optimal_eps:.3f}')
    plt.xlabel(f'Distance to {k}-th neighbor')
    plt.ylabel('Frequency')
    plt.legend()
    plt.title('Distribution of k-distances')
    
    plt.subplot(1, 2, 2)
    plt.plot(sorted_distances, 'b-', alpha=0.7)
    plt.axvline(inflection_idx, color='red', linestyle='--', 
                label=f'Inflection point')
    plt.axhline(optimal_eps, color='green', linestyle='--', 
                label=f'Optimal eps')
    plt.xlabel('Points (sorted)')
    plt.ylabel(f'Distance to {k}-th neighbor')
    plt.legend()
    plt.title('Sorted k-distances with inflection point')
    
    plt.tight_layout()
    plt.show()
    
    print(f"Рекомендуемые параметры метода DBSCAN:")
    print(f"  eps: {optimal_eps:.4f}")
    print(f"  min_samples: {min_samples}")
    print(f"  Обоснование: статистический анализ {k}-расстояний")
    
    return optimal_eps, min_samples

# Использование
optimal_eps, min_samples = analytical_dbscan_params(reduced_data)

# Присваивание объектам номеров кластеров
data_with_clusters = data.copy()
data_with_clusters['cluster'] = clusters

# Дополнение данных объектов индивидуальными значениями метода силуэта
silhouette_vals = silhouette_samples(reduced_data, clusters)
data_with_clusters['silhouette_vals'] = silhouette_vals

# Сохранение результатов кластеризации
data_with_clusters.to_excel('data_with_clusters.xlsx')

# Предварительный просмотр результатов кластерного анализа
print('Предварительный просмотр результатов кластерного анализа:')
#pd.DataFrame({'clusters': clusters, 'silhouette_vals': silhouette_vals})
data_with_clusters.head(5)

# Анализ кластеров

# Количество кластеров (+1, т.к. нумерация с нуля)
clusters_num = max(clusters) + 1
emissions_share = data_with_clusters[data_with_clusters['cluster'] < 0]['cluster'].count() / data_with_clusters['cluster'].count()

print(f'Количество кластеров: {clusters_num}')
print(f'Доля выбросов: {emissions_share:.2%}\n')

# Визуализация результатов
plt.figure(figsize=(15, 5))

# Визуализация кластеров (первые 2 компоненты)
plt.subplot(1, 3, 1)
if reduced_data.shape[1] >= 2:
    plt.scatter(reduced_data[:, 0], reduced_data[:, 1], c=clusters, cmap='tab10', alpha=0.6)
    plt.xlabel('Компонента 1')
    plt.ylabel('Компонента 2')
else:
    # Если одна компонента - гистограмма
    for cluster in range(clusters_nums):
        cluster_data = reduced_data[clusters == cluster, 0]
        plt.hist(cluster_data, alpha=0.6, label=f'Cluster {cluster}')
    plt.xlabel('Значение компоненты')
    plt.ylabel('Частота')
    plt.legend()

plt.title('Визуализация кластеров')

# Размеры кластеров
plt.subplot(1, 3, 2)
cluster_sizes = pd.Series(clusters).value_counts().sort_index()
plt.bar(cluster_sizes.index, cluster_sizes.values)
plt.xlabel('Кластер')
plt.ylabel('Количество объектов')
plt.title('Размеры кластеров')

for i, size in enumerate(cluster_sizes.values):
    plt.text(i, size, str(size), ha='center', va='bottom')

# Качество кластеризации по кластерам
plt.subplot(1, 3, 3)
y_lower = 10
for i in range(clusters_num):
    cluster_silhouette_vals = silhouette_vals[clusters == i]
    cluster_silhouette_vals.sort()
    
    plt.barh(range(y_lower, y_lower + len(cluster_silhouette_vals)),
             cluster_silhouette_vals, height=1)
    plt.text(-0.05, y_lower + len(cluster_silhouette_vals) // 2, str(i))
    y_lower += len(cluster_silhouette_vals) + 10

plt.xlabel('Silhouette Score')
plt.ylabel('Кластер')
plt.title('Silhouette Analysis')

plt.tight_layout()
plt.show()

# Анализ параметров кластеров
def analyzing_cluster_parameters(data_with_clusters, clusters_nums, minimum_cluster_share):
    ''' Анализ параметров кластеров '''
    # data_with_clusters - датафрейм с указанием принадлежности к кластерам
    # cluster_nums - функция типа range(clusters_num) 
    #                для задания номеров кластеров для их перебора циклом
    # minimum_cluster_share - минимальная доля категории внутри кластера для ее учета

    # Анализируем распределение по самым информативным признакам
    # Выбираем признаки с разумным количеством категорий
    analysis_cols = []
    for col in data_with_clusters.columns:
        if 2 <= data_with_clusters[col].nunique() <= 50: # признаки с разумным количеством категорий
            analysis_cols.append(col)
        if len(analysis_cols) >= 30: # максимальное количество информативных признаков
            break
    
    if not analysis_cols:
        # Если не нашли подходящие, берем первые 3 с наименьшим количеством категорий
        col_stats = [(col, data_with_clusters[col].nunique()) for col in data_with_clusters.columns]
        col_stats.sort(key=lambda x: x[1])
        analysis_cols = [col for col, count in col_stats[:3]]
    
    for cluster_num in clusters_nums:
        cluster_data = data_with_clusters[data_with_clusters['cluster'] == cluster_num]
        print(f"\n\n--- Кластер {cluster_num} ({len(cluster_data)} объектов, {len(cluster_data)/len(data_with_clusters):.1%}) ---")
        
        print('\nСилуэтная оценка качества объектов кластера:')
        display(pd.DataFrame({'Min':[data_with_clusters.loc[data_with_clusters['cluster'] == cluster_num, 'silhouette_vals'].min()], 
                              'Mean':[data_with_clusters.loc[data_with_clusters['cluster'] == cluster_num, 'silhouette_vals'].mean()], 
                              'Median':[data_with_clusters.loc[data_with_clusters['cluster'] == cluster_num, 'silhouette_vals'].median()], 
                              'Max':[data_with_clusters.loc[data_with_clusters['cluster'] == cluster_num, 'silhouette_vals'].max()]}).round(3))
        
        col = []
        value = []
        count = []
        percentage = []
        for c in analysis_cols:
            top_value = cluster_data[c].value_counts().head(1)
            if len(top_value) > 0:
                col.append(c)
                value.append(top_value.index[0])
                count.append(top_value.values[0])
                percentage.append(count[-1] / len(cluster_data))
        print('\nКлючевые параметры, характеризующие кластер:')
        display_claster = pd.DataFrame({'Параметр':col, 'Модальное значение':value, 'Количество':count, 'Доля в кластере':percentage})
        display(display_claster[display_claster['Доля в кластере'] > minimum_cluster_share])
    
        print('\nПримеры объектов кластера:')
        display(data_with_clusters[data_with_clusters['cluster'] == cluster_num].head(5))

analyzing_cluster_parameters(data_with_clusters, range(clusters_num), .75)

# Табличное представление параметров кластеров
cluster_parameters = data_with_clusters[data_with_clusters['cluster'] >= 0].groupby(['cluster']).agg(lambda x: x.mode().iloc[0]).reset_index()
cluster_parameters['cluster_size'] = data_with_clusters.groupby(['cluster']).size()
cluster_parameters['percentage_cluster_size'] = cluster_parameters['cluster_size'] / len(data_with_clusters)

# Сохранение полученного табличного представления ключевых параметров кластеров
cluster_parameters.to_excel('cluster_parameters.xlsx')

print('Табличное представление медианных значений ключевых параметров кластеров:')
cluster_parameters

# Итоговая информация
silhouette_avg = data_with_clusters['silhouette_vals'].mean() #silhouette_score(reduced_data, clusters)
print(f"\n=== ИТОГИ ===")
print(f"Исходные данные: {data.shape[1]} категориальных признаков")
print(f"После кодирования: {encoded_data.shape[1]} признаков")
print(f"Для кластеризации: {reduced_data.shape[1]} компонент")
print(f"Число кластеров: {clusters_num}")
print(f"Распределение по кластерам:")
for cluster_num in range(clusters_num):
    count = (clusters == clusters_num).sum()
    print(f"  Кластер {clusters_num}: {count} объектов ({count/len(clusters):.1%})")

# Анализ выбросов, полученных на основе силуэтной оценки объектов сущствующих кластеров
print('Анализ выбросов, полученных на основе силуэтной оценки объектов сущствующих кластеров:')
analyzing_cluster_parameters(data_with_clusters[data_with_clusters['silhouette_vals'] < 0], 
                             data_with_clusters[(data_with_clusters['silhouette_vals'] < 0) & (data_with_clusters['cluster'] >= 0)]['cluster'].unique(), 
                             .75)

# Анализ выбросов, полученных в результате кластеризации методом DBSCAN

print('Анализ выбросов, полученных в результате кластеризации методом DBSCAN:')

cluster_data = data_with_clusters[data_with_clusters['cluster'] < 0]
print(f"\n\n--- Кластер выбросов ({len(cluster_data)} объектов, {len(cluster_data)/len(data_with_clusters):.1%}) ---")
        
print('\nСилуэтная оценка качества объектов кластера выбросов:')
display(pd.DataFrame({'Min':[cluster_data['silhouette_vals'].min()], 
                      'Mean':[cluster_data['silhouette_vals'].mean()], 
                      'Median':[cluster_data['silhouette_vals'].median()], 
                      'Max':[cluster_data['silhouette_vals'].max()]}).round(3))

analysis_cols = []
for col in cluster_data.columns:
    if 2 <= cluster_data[col].nunique() <= 50:
        analysis_cols.append(col)
    if len(analysis_cols) >= 30: 
        break

if not analysis_cols:
    # Если не нашли подходящие, берем первые 3 с наименьшим количеством категорий
    col_stats = [(col, cluster_data[col].nunique()) for col in data.columns]
    col_stats.sort(key=lambda x: x[1])
    analysis_cols = [col for col, count in col_stats[:3]]

col = []
value = []
count = []
percentage = []
for c in analysis_cols:
    top_value = cluster_data[c].value_counts().head(1)
    if len(top_value) > 0:
        col.append(c)
        value.append(top_value.index[0])
        count.append(top_value.values[0])
        percentage.append(count[-1] / len(cluster_data))
print('\nКлючевые параметры, характеризующие кластер:')
display_claster = pd.DataFrame({'Параметр':col, 'Модальное значение':value, 'Количество':count, 'Доля в кластере':percentage})
display(display_claster[display_claster['Доля в кластере'] > .75])

print('\nПримеры объектов кластера:')
display(cluster_data.head(5))