import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVR
from sklearn.model_selection import train_test_split
import streamlit as st
from PIL import Image
import mplfinance as mpf
import matplotlib.pyplot as plt
from scipy.stats import linregress
import yfinance as yf
import streamlit as st
import matplotlib.pyplot as plt
import math
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense , LSTM
from IPython.display import display, Markdown, Latex
import plotly.express as px
plt.style.use('fivethirtyeight')
st.set_option('deprecation.showPyplotGlobalUse', False)




#BTC_EUR = yf.download('BTC-EUR', start='2018-10-01',interval='1d')
#df=BTC_EUR

#plt.plot(df['Close'])









st.write('''
# STOCK & CRYPTO ANALYZER

****

''')





st.sidebar.header('INSERT DATA')
def data():
    n=st.sidebar.text_input('How many days you wanna predict? ',5)
    symbol=st.sidebar.selectbox('Select The Symbol : ',['BTC-USD','BTC-EUR','ETH-EUR','ETH-USD','TRX_EUR','GOLD'])
    mydate = st.sidebar.selectbox('Select The start date : ' ,['2015-01-01','2016-01-01','2017-01-01','2018-01-01','2019-01-01','2020-01-01'] )
    return mydate , n , symbol





mydate , n , symbol = data()





def get_data():
    df = yf.Ticker(symbol)
    df = df.history(period='1d' , start= mydate )
    df['Date'] = df.index
    df = df.set_index(pd.DatetimeIndex(df['Date'].values))
    return df





def get_company_name(symbol):
    if symbol=='BTC-USD':
        return 'BITCOIN'
    elif symbol== 'ETH-EUR':
        return 'ETHEREUM'
    elif symbol== 'ETH-USD':
        return 'ETHEREUM'
    if symbol=='BTC-EUR':
        return 'BITCOIN'
    if symbol=='TRX_EUR':
        return 'TRON'
    if symbol=='GOLD':
        return 'GOLD'
    else :
        return  'NONE'











df=get_data()
company=get_company_name(symbol)
df





df=df[['Close']]
forecast=int(n)
df['Prediction']=df[['Close']].shift(-forecast)
x= np.array(df.drop(['Prediction'],1))
x= x[:-forecast]
y= np.array(df['Prediction'])
y=y[:-forecast]





crypto = get_data()
st.header('Current Price')
st.warning(crypto.tail(1).Close)





xtrain , xtest , ytrain , ytest=train_test_split(x,y,test_size=0.2)
mysvr=SVR(kernel='rbf',C=1000,gamma=0.1)
mysvr.fit(xtrain,ytrain)
svmconf=mysvr.score(xtest,ytest)
st.header('SVM Accuracy')
st.success(svmconf)





x_forecast=np.array(df.drop(['Prediction'],1))[-forecast:]
svmpred=mysvr.predict(x_forecast)
st.header('SVM Prediction')
st.success(svmpred)





lr=LinearRegression()
lr.fit(xtrain,ytrain)
lrconf=lr.score(xtest,ytest)
st.header('LR Accuracy')
st.success(lrconf)





lrpred=lr.predict(x_forecast)
st.header('LR Prediction')
st.success(lrpred)
lrpred



st.header('Trendline : ')

data=crypto
data=data.tail(90)
data0 = data.copy()
data0['date_id'] = ((data0.index.date - data0.index.date.min())).astype('timedelta64[D]')
data0['date_id'] = data0['date_id'].dt.days + 1
data1 = data0.copy()





while len(data1)>3:

    reg = linregress(
                    x=data1['date_id'],
                    y=data1['High'],
                    )
    data1 = data1.loc[data1['High'] > reg[0] * data1['date_id'] + reg[1]]

reg = linregress(
                    x=data1['date_id'],
                    y=data1['High'],
                    )

data0['high_trend'] = reg[0] * data0['date_id'] + reg[1]

data1 = data0.copy()





while len(data1)>3:

    reg = linregress(
                    x=data1['date_id'],
                    y=data1['Low'],
                    )
    data1 = data1.loc[data1['Low'] < reg[0] * data1['date_id'] + reg[1]]

reg = linregress(
                    x=data1['date_id'],
                    y=data1['Low'],
                    )

data0['low_trend'] = reg[0] * data0['date_id'] + reg[1]





plt.figure(figsize=(16,8))
data0['Close'].plot()
data0['high_trend'].plot()
data0['low_trend'].plot()
# plt.savefig('trendline.png')
plt.title('Trendline')
plt.legend()
plt.show()
st.pyplot()
#plt.show()





st.header('ICHIMOKU : ')

#history = data.history(period = '1d' , start = '2021-01-01')
#history

#tenkan_sen
df=get_data()
df['Date'] = df.index

nine_period_high = df['High'].rolling(window=9).max()
nine_period_low = df['Low'].rolling(window=9).min()
df['tenkan-sen'] = (nine_period_high + nine_period_low ) / 2

#kijun_sen
period26_high = df['High'].rolling(window=26).max()
period26_low = df['Low'].rolling(window=26).min()
df['kijun-sen'] = (period26_high + period26_low ) / 2

#senkou_span_a
df['senkou-span-A'] = ((df['tenkan-sen'] + df['kijun-sen'])/2).shift(26)

#senkou_span_b

period52_high = df['High'].rolling(window=52).max()
period52_low = df['Low'].rolling(window=52).min()
df['senkou-span-B'] = ((period52_high + period52_low ) / 2).shift(26)

df['chikou-span'] = df['Close'].shift(-26)

plt.figure(figsize=(16,8))
plt.plot(df['Date'] , df['Close'] , label = 'Close', linewidth = 2)
plt.plot(df['Date'] , df['chikou-span'] , label = 'chikou-span', linewidth = 2)
plt.plot(df['Date'] , df['tenkan-sen'], label = 'tenkan-sen', linewidth = 2)
plt.plot(df['Date'] , df['kijun-sen'] , label = 'kijun-sen', linewidth = 2)
plt.plot(df['Date'] , df['senkou-span-A'] , label = 'senkou-span-A', linewidth = 2)
plt.plot(df['Date'] , df['senkou-span-B'], label = 'senkou-span-B', linewidth = 2)
plt.fill_between(df['Date'] , df['senkou-span-A'] , df['senkou-span-B'] , alpha = 0.25)
plt.title('ICHIMOKU')
plt.legend()
plt.show()
st.pyplot()

st.header('RSI Indicator : ')
# imag=Image.open('C:/Users/Asus/Python Anaconda Projecs/All Test/predictor/trendline.png')
# st.image(imag,width=600)
#st.pyplot()





df = crypto
df=df.tail(1000)
delta=df['Close'].diff(1)
delta.dropna()
up=delta.copy()
down=delta.copy()
up[up<0]=0
down[down>0]=0
period=14
avg_gain=up.rolling(window=period).mean()
avg_loss=abs(down.rolling(window=period).mean())
RS = avg_gain/avg_loss
RSI = 100.0 - (100.0/(1.0+RS))
newdf=pd.DataFrame()
newdf['Close']=df['Close']
newdf['RSI']=RSI
fig , (ax1 , ax2)=plt.subplots(nrows=2 , ncols=1 , figsize=(16,8))
ax1.plot(newdf['Close'],label='Close Price')
ax2.plot(newdf['RSI'],label='RSI')
ax2.axhline(10 , linestyle='--',color='orange',alpha=0.5)
ax2.axhline(20 , linestyle='--',color='green',alpha=0.5)
ax2.axhline(30 , linestyle='--',color='red',alpha=0.5)
ax2.axhline(70 , linestyle='--',color='red',alpha=0.5)
ax2.axhline(80 , linestyle='--',color='green',alpha=0.5)
ax2.axhline(90 , linestyle='--',color='orange',alpha=0.5)
ax1.set_title('RSI Indicator')
# plt.savefig('RSI.png')
plt.show()
st.pyplot()





df= crypto
df=df.tail(1000)
typical_price=(df['Close']+df['High']+df['Low'])/3
period=14
money_flow=typical_price*df['Volume']
positive_flow=[]
negative_flow=[]





for i in range(1,len(typical_price)):
    if typical_price[i]>typical_price[i-1]:
        positive_flow.append(money_flow[i])
        negative_flow.append(0)
    elif typical_price[i]<typical_price[i-1]:
        positive_flow.append(0)
        negative_flow.append(money_flow[i])
        
    else :
        positive_flow.append(0)
        negative_flow.append(0)
        
positive_mf=[]
negative_mf=[]

for i in range(period-1,len(positive_flow)):
    positive_mf.append(sum(positive_flow[i+1-period:i+1]))
                       
for i in range(period-1,len(negative_flow)):
    negative_mf.append(sum(negative_flow[i+1-period:i+1])) 
    
    
mfi=100 * (np.array(positive_mf) / (np.array(positive_mf) + np.array(negative_mf) ) )

df2=pd.DataFrame()
df2['MFI']=mfi

fig , (ax1 , ax2)=plt.subplots(nrows=2,ncols=1,figsize=(16,8))
ax1.plot(df['Close'],label='Close Price')
ax2.plot(df2['MFI'],label='MFI')
ax2.axhline(20,linestyle='--',color="r",alpha=0.5)
ax2.axhline(30,linestyle='--',color="b",alpha=0.5)
ax2.axhline(70,linestyle='--',color="b",alpha=0.5)
ax2.axhline(80,linestyle='--',color="r",alpha=0.5)
ax1.set_title('MFI Visualizer')
plt.show()
st.pyplot()

#MPLfinance
st.header('MPLfinance : ')
df1=df.tail(80)
df2=df.tail(30)

mpf.plot(df2,type='candle')
mpf.plot(df2,type='line')
mpf.plot(df2,type='ohlc')

mpf.plot(df1,type='candle',mav=14)
mpf.plot(df1,type='candle',mav=(7,14))
mpf.plot(df1,type='candle',mav=(7,14,21))

mpf.plot(df1,type='candle',mav=(7,14,21),volume=True)
mpf.plot(df1,type='candle',mav=(7,14,21),volume=True,show_nontrading=True)

plt.title('MPLfinance')
plt.legend()
plt.show()
st.pyplot()

st.header(' : ')
df= crypto
apple = df
ma30=pd.DataFrame()
ma30['AM']=apple['Close'].rolling(window=30).mean()
ma100=pd.DataFrame()
ma100['AM']=apple['Close'].rolling(window=100).mean()


data=pd.DataFrame()
data['AAPL']=apple['Close']
data['MA30']=ma30['AM']
data['MA100']=ma100['AM']


def signal(data) : 
    signalBuy=[]
    signalSell=[]
    f=-1
    for i in range(len(data)):
        if data['MA30'][i]>data['MA100'][i]:
            if f!=1:
                signalBuy.append(data['AAPL'][i])
                signalSell.append(np.nan)
                f=1
            else:
                signalBuy.append(np.nan)
                signalSell.append(np.nan)
        elif data['MA30'][i]<data['MA100'][i]: 
            if f!=0:
                signalBuy.append(np.nan)
                signalSell.append(data['AAPL'][i])
                f=0
            else:
                signalBuy.append(np.nan)
                signalSell.append(np.nan)
        else:
            signalBuy.append(np.nan)
            signalSell.append(np.nan) 

    return (signalBuy , signalSell )   





buy_sell = signal(data)
data['buy signal']=buy_sell[0]
data['sell signal']=buy_sell[1]


plt.figure(figsize=(16,8))
plt.plot(data['AAPL'],label='AAPL',alpha=0.3)
plt.plot(data['MA30'],label='MA30',alpha=0.3)
plt.plot(data['MA100'],label="MA100",alpha=0.3)
plt.scatter(data.index,data['buy signal'],label='BUY',marker='^',color='g')
plt.scatter(data.index,data['sell signal'],label='SELL',marker='v',color='r')
plt.title(' Two Moving Average Indicator') 
plt.xlabel('DATE')
plt.ylabel('PRICE (USD)')
plt.legend()
# plt.savefig('SMA.png')
plt.show()
st.pyplot()


st.header('RSI : ')

plt.figure(figsize=(16,8))
plt.plot(df.index,df['Close'],label='Close Price')
plt.xlabel('Date')
plt.ylabel('Price')
plt.show()

delta=df['Close'].diff(1)
delta.dropna()

up=delta.copy()
down=delta.copy()
up[up<0]=0
down[down>0]=0

period=14
avg_gain=up.rolling(window=period).mean()
avg_loss=abs(down.rolling(window=period).mean())
RS = avg_gain/avg_loss
RSI = 100.0 - (100.0/(1.0+RS))

plt.figure(figsize=(16,8))
RSI.plot()
plt.show()

newdf=pd.DataFrame()
newdf['Close']=df['Close']
newdf['RSI']=RSI
#newdf

fig , (ax1 , ax2)=plt.subplots(nrows=2 , ncols=1 , figsize=(16,8))
ax1.plot(newdf['Close'],label='Close Price')
ax2.plot(newdf['RSI'],label='RSI')
ax2.axhline(10 , linestyle='--',color='orange',alpha=0.5)
ax2.axhline(20 , linestyle='--',color='green',alpha=0.5)
ax2.axhline(30 , linestyle='--',color='red',alpha=0.5)
ax2.axhline(70 , linestyle='--',color='red',alpha=0.5)
ax2.axhline(80 , linestyle='--',color='green',alpha=0.5)
ax2.axhline(90 , linestyle='--',color='orange',alpha=0.5)
ax1.set_title('RSI Indicator')
plt.show()
st.pyplot()




#st.header('SMA : ')


df = crypto
df=df.tail(220)
shortEMA =df.Close.ewm(span=12 , adjust=False).mean()
longEMA =df.Close.ewm(span=26 , adjust=False).mean()
MACD = shortEMA - longEMA
signal = MACD.ewm(span=9 , adjust = False).mean()





plt.figure(figsize=(16,8))
plt.plot(df.index , MACD , label='MACD' , color='red' , alpha=0.5)
plt.plot(df.index , signal , label='Signal' , color='blue' , alpha=0.5)
plt.title('MACD INDICATOR')
plt.xlabel('Date')
plt.ylabel('INDICATOR')
# plt.savefig('MACD1.png')
#plt.show()
st.header('MACD : ')
st.pyplot()

df['MACD']=MACD
df['signal line']=signal





def buy_sell(signal):
    buy=[]
    sell=[]
    f = -1
    for i in range(0 , len(signal)):
        if signal['MACD'][i] > signal['signal line'][i]:
            sell.append(np.nan)
            if f != 1:
                buy.append(signal['Close'][i])
                f=1
            else:
                buy.append(np.nan)
        elif signal['MACD'][i] < signal['signal line'][i]:
            buy.append(np.nan)
            if f != 0:
                sell.append(signal['Close'][i])
                f=0
            else:
                sell.append(np.nan) 
                
        else:
            buy.append(np.nan)
            sell.append(np.nan)
            
    return  buy , sell         





a = buy_sell(df)
df['Buy_Signal'] = a[0]
df['Sell_Signal'] = a[1]

plt.figure(figsize=(16,8))
plt.scatter(df.index , df['Buy_Signal'] , color='green', label='BUY' , marker='^')
plt.scatter(df.index , df['Sell_Signal'] , color='red', label='SELL' , marker='v')
plt.plot(df['Close'],label='Price',alpha = 0.5)
plt.title('MACD INDICATOR')
plt.xlabel('DATE')
plt.ylabel('Indicator')
plt.xticks(rotation=45)
plt.legend()
# plt.savefig('MACD2.png')
plt.show()
st.pyplot()





import math
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense , LSTM
plt.style.use('fivethirtyeight')





df = crypto





data=df.filter(['Close'])
dataset=data.values





training_data_len=math.ceil(len(dataset)*0.8)
scaler=MinMaxScaler(feature_range=(0,1))
scaled_data=scaler.fit_transform(dataset)





training_data=scaled_data[0:training_data_len , :]





xtrain=[]
ytrain=[]
n = 60





for i in range(n,len(training_data)):
    xtrain.append(training_data[i-n:i , 0])
    ytrain.append(training_data[i,0])





xtrain , ytrain = np.array(xtrain) , np.array(ytrain)
xtrain=np.reshape(xtrain , (xtrain.shape[0],xtrain.shape[1],1))





model=Sequential()
model.add(LSTM(50,return_sequences=True,input_shape=(xtrain.shape[1],1)))
model.add(LSTM(50,return_sequences=False))
model.add(Dense(25))
model.add(Dense(1))





model.compile(loss='mean_squared_error',optimizer='adam')





model.fit(xtrain,ytrain,epochs=1,batch_size=1)





test_data=scaled_data[training_data_len - n : , :]
xtest=[]
ytest=dataset[training_data_len : , :]
for i in range(n , len(test_data)):
    xtest.append(test_data[i-n : i , 0])





xtest=np.array(xtest)
xtest=np.reshape(xtest , (xtest.shape[0],xtest.shape[1],1))





prediction=model.predict(xtest)
prediction=scaler.inverse_transform(prediction)
#root mean squared error
rmse=np.sqrt(np.mean((prediction - ytest)**2))





train=data[:training_data_len]
valid=data[training_data_len:]
valid['prediction']=prediction





st.header('Deep Learning Method : ')
plt.figure(figsize=(16,8))
plt.title('Price Predictor Using DL')
plt.xlabel('Date')
plt.ylabel('Price')
plt.plot(train['Close'])
plt.plot(valid[['Close','prediction']])
plt.legend(['Train','Value','Prediction'])
st.pyplot()
plt.show()





st.header('RMSE : ')
st.success(rmse)





newdf=data[-60:].values
scalednewdf=scaler.transform(newdf)





xtest=[]
xtest.append(scalednewdf)
xtest=np.array(xtest)
xtest=np.reshape(xtest,(xtest.shape[0],xtest.shape[1],1))






pred=model.predict(xtest)
pred=scaler.inverse_transform(pred)
print('Next Day Prediction:  ' , pred)





st.header('Deep Learning Prediction : ')
st.success(pred)