import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, roc_auc_score, roc_curve
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
import xgboost as xgb

# 훈련 및 테스트 데이터 로드
train_data = pd.read_csv('train.csv')
test_data = pd.read_csv('test.csv')

print("train data:", train_data.shape)  # (2190, 13)
print("train data info:\n", train_data.info())
print("train data describe:\n", train_data.describe())
print("train data isnull:\n", train_data.isnull().sum())
print("test data isnull:\n", test_data.isnull().sum())
print("train data rainfall value_counts:\n", train_data['rainfall'].value_counts())
print(f"train data rainfall value_counts(normalize):\n{train_data['rainfall'].value_counts(normalize=True)}")

correlation = train_data.corr()
plt.figure(figsize=(12, 10))
sns.heatmap(correlation, annot=True, cmap="coolwarm", linewidths=0.5)
plt.title('correlation between features')
plt.tight_layout()
plt.show()
plt.close()

rainfall_corr = correlation['rainfall'].sort_values(ascending=False)
print("correlation between rainfall and each features:")
print(rainfall_corr)

# 온도 차이 (대기 불안정성 지표)
train_data['temp_diff'] = train_data['maxtemp'] - train_data['mintemp']
test_data['temp_diff'] = test_data['maxtemp'] - test_data['mintemp']

# 기온과 이슬점 차이 (습도 지표)
train_data['temp_dewpoint_diff'] = train_data['temparature'] - train_data['dewpoint']
test_data['temp_dewpoint_diff'] = test_data['temparature'] - test_data['dewpoint']

# 날짜의 주기성 인코딩
train_data['day_sin'] = np.sin(2 * np.pi * train_data['day'] / 365.25)
train_data['day_cos'] = np.cos(2 * np.pi * train_data['day'] / 365.25)
test_data['day_sin'] = np.sin(2 * np.pi * test_data['day'] / 365.25)
test_data['day_cos'] = np.cos(2 * np.pi * test_data['day'] / 365.25)

# 훈련/테스트 특성 준비
train_features = train_data.drop(['id', 'day', 'rainfall'], axis=1)
test_features = test_data.drop(['id', 'day'], axis=1)

# 타겟 변수 추출
train_target = train_data['rainfall']

# 훈련/검증 데이터 분할
X_train, X_val, y_train, y_val = train_test_split(
    train_features, train_target, test_size=0.2, random_state=42, stratify=train_target
)

# 표준화 스케일링
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_val_scaled = scaler.transform(X_val)
test_scaled = scaler.transform(test_features)

print("train data shape:", X_train.shape)
print("validation data shape:", X_val.shape)
print("test data shape:", test_features.shape)

# 다양한 모델 정의
models = {
    'Logistic Regression': LogisticRegression(max_iter=1000, random_state=42),
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
    'Gradient Boosting': GradientBoostingClassifier(n_estimators=100, random_state=42),
    'XGBoost': xgb.XGBClassifier(n_estimators=100, random_state=42)
}

results = {}

# 각 모델 훈련 및 평가
for name, model in models.items():
    # 모델 훈련
    model.fit(X_train_scaled, y_train)
    
    # 검증 데이터 예측
    val_pred = model.predict(X_val_scaled)
    val_prob = model.predict_proba(X_val_scaled)[:, 1] if hasattr(model, 'predict_proba') else None
    
    # 성능 평가
    accuracy = accuracy_score(y_val, val_pred)
    report = classification_report(y_val, val_pred)
    cm = confusion_matrix(y_val, val_pred)
    auc = roc_auc_score(y_val, val_prob) if val_prob is not None else None
    
    # 결과 저장
    results[name] = {
        'model': model,
        'accuracy': accuracy,
        'auc': auc,
        'report': report,
        'confusion_matrix': cm
    }
    
    # 결과 출력
    print(f"\n{name} model performance:")
    print(f"Accuracy: {accuracy:.4f}")
    print(f"AUC: {auc:.4f}" if auc is not None else "AUC: None")
    print("\nClassification Report:")
    print(report)
    
    # 혼동 행렬 시각화
    plt.figure(figsize=(8, 6))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False)
    plt.title(f'{name} - Confusion Matrix')
    plt.ylabel('True Label')
    plt.xlabel('Predicted Label')
    plt.show()
    plt.close()

# 최고 성능 모델 선택
best_model_name = max(results, key=lambda x: results[x]['accuracy'])
best_model = results[best_model_name]['model']
print(f"best model: {best_model_name}")
print(f"accuracy: {results[best_model_name]['accuracy']:.4f}")
print(f"AUC: {results[best_model_name]['auc']:.4f}" if results[best_model_name]['auc'] is not None else "AUC: None")

# 특성 중요도 시각화 (트리 기반 모델)
if hasattr(best_model, 'feature_importances_'):
    feature_importances = pd.DataFrame({
        'feature': train_features.columns,
        'importance': best_model.feature_importances_
    }).sort_values('importance', ascending=False)

    plt.figure(figsize=(12, 8))
    sns.barplot(x='importance', y='feature', data=feature_importances)
    plt.title(f'{best_model_name} - feature importance')
    plt.tight_layout()
    plt.show()
    plt.close()
    print("\nfeature importance:")
    print(feature_importances)

# 하이퍼파라미터 그리드 정의
if best_model_name == 'Random Forest':
    param_grid = {
        'n_estimators': [100, 200, 300],
        'max_depth': [None, 10, 20, 30],
        'min_samples_split': [2, 5, 10],
        'min_samples_leaf': [1, 2, 4]
    }
elif best_model_name == 'Gradient Boosting':
    param_grid = {
        'n_estimators': [100, 200, 300],
        'learning_rate': [0.01, 0.05, 0.1],
        'max_depth': [3, 5, 7],
        'min_samples_split': [2, 5, 10],
        'min_samples_leaf': [1, 2, 4]
    }
elif best_model_name == 'XGBoost':
    param_grid = {
        'n_estimators': [100, 200, 300],
        'learning_rate': [0.01, 0.05, 0.1],
        'max_depth': [3, 5, 7],
        'subsample': [0.7, 0.8, 0.9],
        'colsample_bytree': [0.7, 0.8, 0.9]
    }
else:  # Logistic Regression
    param_grid = {
        'C': [0.01, 0.1, 1, 10, 100],
        'penalty': ['l1', 'l2'],
        'solver': ['liblinear', 'saga']
    }

# 그리드 서치 수행
grid_search = GridSearchCV(
    estimator=best_model,
    param_grid=param_grid,
    cv=5,
    scoring='accuracy',
    verbose=1,
    n_jobs=-1
)

print("running grid search...")
grid_search.fit(X_train, y_train)

print(f"optimal hyperparameter: {grid_search.best_params_}")
print(f"optimal cross-validation score: {grid_search.best_score_:.4f}")

# 최적 파라미터로 모델 재학습
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# 검증 데이터로 성능 평가
y_pred = best_model.predict(X_val_scaled)
y_prob = best_model.predict_proba(X_val_scaled)[:, 1] if hasattr(best_model, 'predict_proba') else None

print(f"\nbest model performance (validation data):")
print(f"Accuracy: {accuracy_score(y_val, y_pred):.4f}")
print(f"AUC: {roc_auc_score(y_val, y_prob):.4f}" if y_prob is not None else "AUC: None")
print("\nClassification Report:")
print(classification_report(y_val, y_pred))

# 테스트 데이터 예측
print("\n# predict with test data")
test_pred = best_model.predict(test_scaled)
test_prob = best_model.predict_proba(test_scaled)[:, 1] if hasattr(best_model, 'predict_proba') else None

# 제출 파일 생성
submission = pd.DataFrame({
    'id': test_data['id'],
    'rainfall': test_pred
})

# 예측 결과 분포 확인
print("predict result distribution:")
print(submission['rainfall'].value_counts())

# 제출 파일 저장
submission.to_csv('submission.csv', index=False)
print("submission file created: 'submission.csv'")