import sklearn
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from xgboost import XGBClassifier
from sklearn import metrics, model_selection
from sklearn.model_selection import GridSearchCV, train_test_split

def pcc(y, factor=1.25):
        """
        PARAMETERS
        ----------
        factor: float
            Applied factor to the Pcc to determine target test accuracy

        RETURNS
        -------
        pcc: float
            The proportional chance criteria
        """
        counts = np.unique(y, return_counts=True)[1]
        num = (counts/counts.sum())**2

        pcc = 100*factor*num.sum()

        return pcc

def generate_features(df, window_range=5):
    """ Generate features for a stock/index/currency/commodity based on 
    historical price and performance

    PARAMETERS
    ----------
        df : pandas DataFrame
            dataframe with columns "open", "close", "high", "low", "volume"
        window_range: int, optional (default=5)
            lagged time to include in the features

    RETURNS
    -------
        df_new : pandas DataFrame
            data set with new features
    """

    df_new = pd.DataFrame(index=df.index)

    # original features lagged
    for window in range(1, window_range+1):
        df_new[f'open_lag_{window}'] = df['open'].shift(window)
        df_new[f'close_lag_{window}'] = df['close'].shift(window)
        df_new[f'high_lag_{window}'] = df['high'].shift(window)
        df_new[f'low_lag_{window}'] = df['low'].shift(window)
        df_new[f'vol_lag_{window}'] = df['volume'].shift(window)

    # special features
    df_new['trigger'] = df['trigger'].shift(1)
    df_new['ema_lagged'] = df['ma_short'].shift(1)

    # average price
    df_new['MA_5'] = df['close'].rolling(window=5).mean().shift(1)
    df_new['MA_21'] = df['close'].rolling(window=21).mean().shift(1)

    # average price ratio
    df_new['ratio_MA_5_21'] = df_new['MA_5'] / df_new['MA_21']

    # standard deviation of prices
    df_new['std_price_5'] = df['close'].rolling(window=5).std().shift(1)
    df_new['std_price_21'] = df['close'].rolling(window=21).std().shift(1)

    # standard deviation ratio of prices
    df_new['ratio_std_price_5_21'] = (df_new['std_price_5']
                                      / df_new['std_price_21'])

    df_new = df_new.dropna(axis=0)

    # targets, check the highest gold price attained in the next 4 hours
    highs = df['high'].rolling(window=4).max().shift(-4)
    df_new['high_close_diff'] = highs - df['close'].shift(1)

    return df_new


data = generate_features(df, window_range=21)

def reco(x):
    if x.high_close_diff > 3.3:
        return 1
    else:
        return 0


data['target'] = data.apply(reco, axis=1)

targets = data['target']
X = data.drop(['target', 'high_close_diff'], axis=1)

startDATE = datetime.datetime(2015, 9, 11, 1)
testDATE = datetime.datetime(2018, 1, 18, 1)

X_train = X.loc[startDATE:testDATE]
y_train = targets.loc[startDATE:testDATE]

X_test = X.loc[testDATE:]
y_test = targets.loc[testDATE:]

X_train.shape, X_test.shape, y_train.shape, y_test.shape

pcc(y_train)

np.unique(y_train, return_counts=True)

from imblearn import over_sampling

sampler = over_sampling.SMOTE()
X_sampled, y_sampled = sampler.fit_resample(X_train, y_train)

np.unique(y_sampled, return_counts=True)

log_reg = LogisticRegression(max_iter=1000)

params_log = {'C': [0.001, 0.01, 0.1, 1],
                   'penalty':['l2']}

log_gs = GridSearchCV(log_reg,    
                        param_grid=params_log,
                        scoring='precision', 
                        cv=5, 
                        verbose=10,
                        n_jobs=-1)

log_gs.fit(X_sampled, y_sampled) 

print("Best parameters found: ", log_gs.best_params_)

log_best = log_gs.best_estimator_

predictions_log = log_best.predict(X_test)

print(metrics.classification_report(y_test, predictions_log))

lsvm = LinearSVC(max_iter=10000)

lsvm_param_grid = {'C': [1e-5, 1e-4, 1e-2]}

lsvm_gs = GridSearchCV(lsvm,    
                        param_grid=lsvm_param_grid,
                        scoring='precision_macro', 
                        cv=5, 
                        verbose=1,
                       n_jobs=-1)

lsvm_gs.fit(X_sampled, y_sampled) 

print("Best parameters found: ", lsvm_gs.best_params_)

lsvm_best = lsvm_gs.best_estimator_

predictions_lsvm = lsvm_best.predict(X_test.values)

print(metrics.classification_report(y_test, predictions_lsvm))

rf = RandomForestClassifier()

rf_param_grid = {'max_depth': range(8,11), 'n_estimators': range(100,201,20)}

rf_gs = GridSearchCV(rf,    
                        param_grid=rf_param_grid,
                        scoring='precision_macro', 
                        cv=5, 
                        verbose=1,
                       n_jobs=-1)

rf_gs.fit(X_sampled, y_sampled) 

print("Best parameters found: ", rf_gs.best_params_)

rf_best = rf_gs.best_estimator_

predictions_rf = rf_best.predict(X_test.values)

print(metrics.classification_report(y_test, predictions_rf))

gb = GradientBoostingClassifier()

gb_param_grid = {'max_depth': range(8,11), 'n_estimators': range(100,201,20)}

gb_gs = GridSearchCV(gb,    
                        param_grid=gb_param_grid,
                        scoring='precision_macro', 
                        cv=5, 
                        verbose=1,
                       n_jobs=-1)

gb_gs.fit(X_sampled, y_sampled) 

print("Best parameters found: ", gb_gs.best_params_)

gb_best = gb_gs.best_estimator_

predictions_gb = gb_best.predict(X_test.values)

print(metrics.classification_report(y_test, predictions_gb))

pred_df = df.loc[testDATE:valiDATE]
pred_df['label'] = y_test
pred_df['pred'] = lsvm_best.predict(X_test)
pred_df.head()

equity = 100
sl_threshold = 1
committed = False
buy_price = 0
prediction = 0
hold_time = 0
bet = 0
target_price = 0
stop_loss = 0

trade_count = 0
equity_change = []
trade_results = []
delta_results = []
bet_list = []
target_list = []
buy_list = []
selling_list = []
time = []
sl_list = []

for _, hour in pred_df.iterrows():
    if committed:
        if hold_time < 4:
            if hour.high >= target_price:
                # win, sell current holdings
                pip = (target_price - buy_price - 0.3)*100
                equity += pip*bet
                delta_results.append(pip*bet)
                equity_change.append(equity)
                selling_list.append(target_price)
                trade_results.append(1)
                committed = False
            else:
                # did not win yet, keep check stop_loss
                if hour.low < stop_loss:
                    pip = (stop_loss - buy_price - .3)*100
                    equity += pip*bet
                    delta_results.append(pip*bet)
                    selling_list.append(stop_loss)
                    equity_change.append(equity)
                    trade_results.append(0)
                    committed = False
                else:
                    hold_time += 1                    
        else:
            # lose, sell current holdings at open price
            pip = (np.abs(hour.open - buy_price)-0.3)*100
            equity -= pip*bet
            delta_results.append(-pip*bet)
            equity_change.append(equity)
            selling_list.append(hour.open)
            trade_results.append(0)
            committed = False
    else:
        if hour.pred != 0:
            trade_count += 1
            committed = True
            buy_price = hour.open
            bet = equity/10000
            bet_list.append(bet)
            prediction = hour.pred
            hold_time = 0
            
            target_price = buy_price + 3
            stop_loss = buy_price - sl_threshold
            
            buy_list.append(buy_price)
            target_list.append(target_price)
            time.append(hour.name)
            sl_list.append(stop_loss)
        else:
            committed = False

xcheck = pd.DataFrame(dict(buy=buy_list,
                           target=target_list,
                           stop_loss=sl_list,
                           sell=selling_list,
                           bet=bet_list,
                           delta=delta_results,
                          equity=equity_change), index=time)
xcheck

fig, ax = plt.subplots(figsize=(16,9))
ax.plot(range(1, trade_count+1), equity_change)
ax.set_ylabel('Equity (USD)')
ax.set_xlabel('Trades Taken')
ax.grid(False)
ax.yaxis.grid(True)
ax.axis([0,380, 70, 170])

for i, tr in enumerate(trade_results):
    if tr == 1:
        ax.axvline(x=(i+1), c='g', ls='--', lw=0.5)
    else:
        ax.axvline(x=(i+1), c='r', ls='--', lw=0.5)

# ax.spines['left'].set_position(('data', 0))