import pandas as pd
# Ler o arquivo corretamente (apenas )
df = pd.read_excel("docs/arvore-decisao/crashcar.xlsx")

# Visualização inicial da base de dados
print('Formato do dataset:', df.shape)

    for col in df:
    print(col, ":", df[col].dtype, "\n")

# Estatísticas descritivas das colunas numéricas
print('Estatísticas das colunas numéricas:')
print(df[['Year', 'Month', 'Day', 'Hour', 'Latitude']].describe())

print(df.shape)
print("Tamanho do dataset antes remoção de valores ausentes")
df = df.dropna()
print(df.shape)
print("Tamanho do dataset após remoção de valores ausentes")

    # Selecionar features para o modelo
    features = ['Year', 'Month', 'Day', 'Hour', 'Collision Type Num', 'Weekend Num', 'Primary Factor Num', 'Latitude', 'Longitude']
    X = df[features]
    y = df['Injury Type Num']  # Variável alvo: 1 para fatal, 0 para não fatal

    # Verificar balanceamento das classes
    print("Distribuição das classes:<br>")

    print(y.value_counts())
    print(f"<br>Proporção de acidentes fatais: {y.mean():.4f}<br>")

    # Dividir os dados em treino e teste
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

    # Normalizar os dados
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)

    # Implementação do KNN
    class KNNClassifier:
        def __init__(self, k=3):
            self.k = k

        def fit(self, X, y):
            self.X_train = X
            self.y_train = y

        def predict(self, X):
            predictions = [self._predict(x) for x in X]
            return np.array(predictions)

        def _predict(self, x):
            # Calcular distâncias euclidianas
            distances = [np.sqrt(np.sum((x - x_train)**2)) for x_train in self.X_train]
            # Obter índices dos k-vizinhos mais próximos
            k_indices = np.argsort(distances)[:self.k]
            # Obter os rótulos correspondentes
            k_nearest_labels = [self.y_train.iloc[i] for i in k_indices]
            # Retornar a classe majoritária
            most_common = max(set(k_nearest_labels), key=k_nearest_labels.count)
            return most_common

    # Treinar e avaliar o modelo

    knn = KNeighborsClassifier(n_neighbors=5)
    knn.fit(X_train_scaled, y_train)
    predictions = knn.predict(X_test_scaled)
    # Métricas de avaliação
    accuracy = accuracy_score(y_test, predictions)

plt.figure(figsize=(6, 5))
plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
plt.title('Matriz de Confusão')
plt.colorbar()
tick_marks = range(len(cm))
plt.xticks(tick_marks, ['Não Fatal', 'Fatal'])
plt.yticks(tick_marks, ['Não Fatal', 'Fatal'])
plt.xlabel('Predito')
plt.ylabel('Real')

for i in range(cm.shape[0]):
    for j in range(cm.shape[1]):
        plt.text(j, i, str(cm[i, j]), ha='center', va='center', color='black')

plt.tight_layout()
buffer = StringIO()
plt.savefig(buffer, format="svg", transparent=True)
plt.close()
print(buffer.getvalue())

# Visualizar fronteira de decisão
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = knn.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, cmap=plt.cm.RdYlBu, alpha=0.3)
for label in np.unique(y):
    plt.scatter(X[y == label, 0], X[y == label, 1], label=f"Classe {label}", s=100)
plt.xlabel("Chance de acidente fatal")
plt.ylabel("Chance de acidente não fatal")
plt.title("Fronteira de Decisão KNN ")
plt.legend()

buffer = StringIO()
plt.savefig(buffer, format="svg", transparent=True)
plt.close()

print(buffer.getvalue())