import pandas as pd
import numpy as np

from sklearn.preprocessing import StandardScaler
import statsmodels.api as sm

import random
import time
import os

import datetime

import xgboost
from xgboost import XGBRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import explained_variance_score
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV

from statsmodels.stats.outliers_influence import variance_inflation_factor


import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline

import warnings
warnings.filterwarnings('ignore')

plt.rcParams['font.family'] = 'NanumGothic'
plt.rcParams['font.size'] = 13

def seed_everything(seed):
    random.seed(seed)
    os.environ['PYTHONHASHSEED'] = str(seed)
    np.random.seed(seed)

seed_everything(42) # Seed 고정

train = pd.read_csv('data/train.csv')
test = pd.read_csv('data/test.csv')

# train_x는 독립변수이므로 종속변수(풍속 (m/s))를 제거합니다. 
# 또한 target 이외의 분석에 활용하지 않는 데이터(id)를 제거합니다.
train_x = train.drop(columns=['ID', '풍속 (m/s)'], axis = 1)

# train_y는 종속변수로 값을 설정합니다.
train_y = train['풍속 (m/s)']

# train에서와 마찬가지로 분석에 활용하지 않는 데이터(id)를 제거합니다.
test_x = test.drop(columns=['ID'])

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
le = le.fit(train_x['측정 시간대'])
train_x['측정 시간대'] = le.transform(train_x['측정 시간대'])
test_x['측정 시간대'] = le.transform(test_x['측정 시간대'])

df = train_x.copy()

## 전진 단계별 선택법
variables = df.columns.tolist() ## 설명 변수 리스트
 
y = train_y ## 반응 변수
selected_variables = [] ## 선택된 변수들
sl_enter = 0.05
sl_remove = 0.05

sv_per_step = [] ## 각 스텝별로 선택된 변수들
adjusted_r_squared = [] ## 각 스텝별 수정된 결정계수
steps = [] ## 스텝
step = 0
while len(variables) > 0:
    remainder = list(set(variables) - set(selected_variables))
    pval = pd.Series(index=remainder) ## 변수의 p-value
    ## 기존에 포함된 변수와 새로운 변수 하나씩 돌아가면서 
    ## 선형 모형을 적합한다.
    for col in remainder: 
        X = df[selected_variables+[col]]
        X = sm.add_constant(X)
        model = sm.OLS(y,X).fit()
        pval[col] = model.pvalues[col]
 
    min_pval = pval.min()
    if min_pval < sl_enter: ## 최소 p-value 값이 기준 값보다 작으면 포함
        selected_variables.append(pval.idxmin())
        ## 선택된 변수들에대해서
        ## 어떤 변수를 제거할지 고른다.
        while len(selected_variables) > 0:
            selected_X = df[selected_variables]
            selected_X = sm.add_constant(selected_X)
            selected_pval = sm.OLS(y,selected_X).fit().pvalues[1:] ## 절편항의 p-value는 뺀다
            max_pval = selected_pval.max()
            if max_pval >= sl_remove: ## 최대 p-value값이 기준값보다 크거나 같으면 제외
                remove_variable = selected_pval.idxmax()
                selected_variables.remove(remove_variable)
            else:
                break
        
        step += 1
        steps.append(step)
        adj_r_squared = sm.OLS(y,sm.add_constant(df[selected_variables])).fit().rsquared_adj
        adjusted_r_squared.append(adj_r_squared)
        sv_per_step.append(selected_variables.copy())
    else:
        break

# train_x = train_x.drop(['실제 증기압(mbar)', '포화 증기압(mbar)', '이슬점 온도(°C)', '절대 온도(K)'], axis=1)
train_x = train_x.drop(['증기압 부족량(mbar)', '측정 시간대'], axis=1)

# test_x = test_x.drop(['실제 증기압(mbar)', '포화 증기압(mbar)', '이슬점 온도(°C)', '절대 온도(K)'], axis=1)
test_x = test_x.drop(['증기압 부족량(mbar)', '측정 시간대'], axis=1)

train_x = train_x.drop('풍향 (deg)', axis=1)
test_x = test_x.drop('풍향 (deg)', axis=1)

train_x = train_x.drop(['절대 온도(K)', '이슬점 온도(°C)', '공기 밀도 (g/m**3)', '포화 증기압(mbar)', '수증기 함량 (g/kg)'], axis=1)
test_x = test_x.drop(['절대 온도(K)', '이슬점 온도(°C)', '공기 밀도 (g/m**3)', '포화 증기압(mbar)', '수증기 함량 (g/kg)'], axis=1)

# 학습 데이터와 테스트 데이터로 분리
X_train, X_test, y_train, y_test = train_test_split(train_x, train_y, test_size=0.2, shuffle=True, random_state=42)

# 학습 데이터로 StandardScaler 객체 생성 및 적용
scaler = StandardScaler()
scaler.fit(X_train)

# 학습 데이터와 테스트 데이터를 각각 표준화
X_train_scaled = scaler.transform(X_train)
X_test_scaled = scaler.transform(X_test)

# # 'col1', 'col2', 'col3' 컬럼만 선택하여 스케일링할 경우
# selected_cols = ['col1', 'col2', 'col3']

# # StandardScaler 객체 생성
# scaler = StandardScaler()

# # 'col1', 'col2', 'col3' 컬럼만 스케일링하기 위해 해당 컬럼들을 추출하여 스케일링
# X_train_scaled_selected = X_train[selected_cols].copy()
# X_train_scaled_selected = scaler.fit_transform(X_train_scaled_selected)

# # 스케일링된 컬럼들을 다시 원래 X_train에 삽입
# X_train[selected_cols] = X_train_scaled_selected

# # 나머지 컬럼들은 스케일링하지 않으므로 그대로 사용
# # ...

# # 위와 동일한 방식으로 X_test에 대해서도 스케일링 수행
# X_test_scaled_selected = X_test[selected_cols].copy()
# X_test_scaled_selected = scaler.transform(X_test_scaled_selected)
# X_test[selected_cols] = X_test_scaled_selected

# # 나머지 컬럼들은 스케일링하지 않으므로 그대로 사용
# # ...

from hyperopt import fmin, tpe, hp, Trials

# 데이터를 준비하고 X_train, y_train, X_test, y_test로 나누는 등의 전처리 작업을 수행합니다.

# Objective 함수 정의 (하이퍼파라미터 튜닝 대상)
def objective(params):
    model = XGBRegressor(
        n_estimators=int(params['n_estimators']),
        max_depth=int(params['max_depth']),
        learning_rate=params['learning_rate'],
        reg_lambda=params['reg_lambda'],
        colsample_bytree=params['colsample_bytree'],
        max_leaves=int(params['max_leaves']),
        subsample=params['subsample'],
        gamma=params['gamma'],
        
        random_state=42,
        n_jobs=-1,
        # tree_method='gpu_hist', gpu_id=0
    )
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    mae = mean_absolute_error(y_test, y_pred)
    return mae

# 하이퍼파라미터 공간 정의
space = {
    'n_estimators': hp.quniform('n_estimators', 150, 250, 1),
    'max_depth': hp.quniform('max_depth', 10, 20, 1),
    'learning_rate': hp.loguniform('learning_rate', np.log(0.001), np.log(0.1)),
    'reg_lambda': hp.loguniform('reg_lambda', 0.01, 5.0),
    'colsample_bytree': hp.uniform('colsample_bytree', 0.1, 1.0),
    'max_leaves': hp.quniform('max_leaves', 20, 40, 1),
    'subsample': hp.uniform('subsample', 0.1, 1.0),
    'gamma': hp.uniform('gamma', 0.0, 0.5)
}

# 최적의 하이퍼파라미터로 모델 생성
best_model = XGBRegressor(
    n_estimators=int(best['n_estimators']),
    max_depth=int(best['max_depth']),
    learning_rate=best['learning_rate'],
    reg_lambda=best['reg_lambda'],
    colsample_bytree=best['colsample_bytree'],
    max_leaves=int(best['max_leaves']),
    subsample=best['subsample'],
    gamma=best['gamma'],
    
    random_state=42,
    n_jobs=-1,
    # tree_method='gpu_hist', gpu_id=0
)

# dt_pred = dt_clf.predict(test_x) 

# 테스트 데이터로 예측
xgb_pred = best_model.predict(test_x)

submission = pd.read_csv('./data/sample_submission.csv')

submission.to_csv('submission/submission_'+datetime.datetime.now().strftime("%Y%m%d%H%M")+'.csv', index=  False)