import pandas as pd
import numpy as np
from pandas import DataFrame, Series

import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style("darkgrid")
%matplotlib inline

import pandas_datareader as pdr
from pandas_datareader import data, wb

from datetime import datetime

# list of each tech stocks

tech_list = ['AAPL','FB','AMZN','GOOG']

# making the appropriate timeframe
end = datetime.now()
start = datetime(end.year-1, end.month, end.day)

# Quick ex of all the stocks

temp = pdr.get_data_yahoo('FB')
temp.reset_index(level=0, inplace=True) ## Changing the index value

temp.head()

for stock in tech_list:
    temp = pdr.get_data_yahoo(stock)
    temp.reset_index(level=0, inplace=True) ## Changing the index value
    
    globals()[stock] = temp[temp['Date'] >= start]

# Resetting all index 
AAPL.reset_index(inplace=True)
FB.reset_index(inplace=True)
AMZN.reset_index(inplace=True)
GOOG.reset_index(inplace=True)

# del the extra cols.
del AAPL['index']
del FB['index']
del AMZN['index']
del GOOG['index']

GOOG.head()

GOOG.describe()

GOOG.info()

GOOG['Adj Close'].plot(legend=True,figsize = (10,4))

GOOG.plot(y="Volume",x="Date",legend=True,figsize = (10,4))

ma_day = [10,20,50]

for ma in ma_day:
    colname = "MA for {0} days".format(ma)
    
    # For the AAPL STOCK
    AAPL[colname] = AAPL['Adj Close'].rolling(window=ma).mean()

AAPL.head(10)

AAPL[["Adj Close", "MA for 10 days","MA for 20 days","MA for 50 days"]].plot(subplots=False, figsize = (10,4))
plt.show()

AAPL['Daily Returns'] = AAPL['Adj Close'].pct_change()

AAPL['Daily Returns'].plot(figsize=(14,6), legend=True, linestyle='--', marker='o')
plt.show()

sns.distplot(AAPL['Daily Returns'].dropna(), bins=100, color='purple')
plt.show()

AAPL['Daily Returns'].hist(bins=100)

AAPL.head()

AAPL['Adj Close'].head()

GOOG['Adj Close'].head()

FB['Adj Close'].head()

#closing_df = pdr(tech_list, 'yahoo', start, end)['Adj Close']
closing_df = DataFrame({
    "AAPL": AAPL['Adj Close'],
    "GOOG": GOOG['Adj Close'],
    "FB": FB['Adj Close'],
    "AMZN": AMZN['Adj Close']
    
})
closing_df.head()

big4_returns = closing_df.pct_change()

big4_returns.drop(big4_returns.index[0], inplace=True)

big4_returns.head()

for x in tech_list:
    for y in tech_list:
        if x != y:
            sns.jointplot(x, y, big4_returns)
            plt.title(('{0} and {1}').format(x,y)) # Various CI
            plt.show()

from IPython.display import SVG
SVG(url='http://upload.wikimedia.org/wikipedia/commons/d/d4/Correlation_examples2.svg')

big4_returns.head()

# Pairplot
sns.pairplot(big4_returns.dropna())

# create our pairplot

returns_fig = sns.PairGrid(big4_returns.dropna())

returns_fig.map_upper(plt.scatter,color='orange')
returns_fig.map_lower(sns.kdeplot,cmpa='cool_d')
returns_fig.map_diag(plt.hist,bins=30)
plt.show()

# create our pairplot

returns_fig = sns.PairGrid(closing_df.dropna())

returns_fig.map_upper(plt.scatter,color='orange')
returns_fig.map_lower(sns.kdeplot,cmpa='cool_d')
returns_fig.map_diag(plt.hist,bins=30)
plt.show()

big4_returns.corr()

# Compute the correlation matrix
corr = big4_returns.corr()

# Generate a mask for the upper triangle
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True

# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(11, 9))

# Generate a custom diverging colormap
cmap = sns.diverging_palette(220, 10, as_cmap=True)

# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(corr, mask=mask, annot=True, vmax=.3, center=0,
            square=True, linewidths=.5, cbar_kws={"shrink": .5})

# Compute the correlation matrix
corr = closing_df.corr()

# Generate a mask for the upper triangle
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True

# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(11, 9))

# Generate a custom diverging colormap
cmap = sns.diverging_palette(220, 10, as_cmap=True)

# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(corr, mask=mask, annot=True, vmax=.3, center=0,
            square=True, linewidths=.5, cbar_kws={"shrink": .5})

rets = big4_returns.dropna()
area = np.pi * 20
plt.scatter(x=rets.mean(), y=rets.std(), s=area)

plt.xlabel('Expected Return')
plt.ylabel('Risk')


# Label the scatter plots, for more info on how this is done, chekc out the link below
# http://matplotlib.org/users/annotations_guide.html
for label, x, y in zip(rets.columns, rets.mean(), rets.std()):
    plt.annotate(
        label, 
        xy = (x, y), xytext = (50, 50),
        textcoords = 'offset points', ha = 'right', va = 'bottom',
        arrowprops = dict(arrowstyle = '-', connectionstyle = 'arc3,rad=-0.3'))

# Note the use of dropna() here, otherwise the NaN values can't be read by seaborn
sns.distplot(AAPL['Daily Returns'].dropna(),bins=100,color='purple')

# The 0.05 empirical quantile of daily returns
rets['AAPL'].quantile(0.05)

from collections import defaultdict

# Let perform for all of them with differernt ranges
ranges = [0.025, 0.05, 0.1]
var_d = defaultdict(list)


for t_stock in tech_list:
    for val in ranges:
        ret = rets[t_stock].quantile(val)
        var_d[t_stock].append(ret)
var_d

df_VaR = DataFrame(var_d)
df_VaR

big4_returns.head()

# Setting time horizon

days = 365
dt = 1/days

rets.head()

def stock_monte_carlo(*args):
    start_price, days, mu, sigma = args
    
    price = np.zeros(days)
    price[0] = start_price
    
    shock = np.zeros(days)
    drift = np.zeros(days)
    
    for x in range(1, days):
        shock[x] = np.random.normal(loc=mu*dt, scale=sigma*np.sqrt(dt))
        
        drift[x] = mu*dt
        
        price[x] = price[x-1] +(price[x-1] * (drift[x] + shock[x]))
    
    return price

def get_metrics(tck, df):
    mu = df.mean()[tck]
    sigma = df.std()[tck]
    return(mu, sigma, tck)
    

def run_simulations(*args):
    days = 365
    start_price, mu, sigma = args
    
    runs = 10000
    simulation = np.zeros(runs)

    for run in range(runs):
        simulation[run] = stock_monte_carlo(start_price, days, mu, sigma)[days-1] # do not know why days-1
    return simulation

def plot_histogram(*args):
    simulation, start_price, tck = args
    
    q = np.percentile(simulation,1)
    plt.hist(simulation, 150)

    plt.figtext(0.62,0.8, s="Start Price: {0:.2f}".format(start_price))

    # Mean
    plt.figtext(0.62,0.7, s="Mean final price: {0:.2f}".format(simulation.mean()))

    # Variance
    plt.figtext(0.62,0.6, s="VaR(0.99): {0:.2f}".format(start_price-q))

    # Display 1 Percent Quantile
    plt.figtext(0.13,0.6,"q(0.99): {0:.2f}".format(q))

    # Plot a line at the 1% quantile result
    plt.axvline(x=q, linewidth=4, color='r')

    plt.title("Final price distribution for {0} Stock after 365 days".format(tck))

def create_monte_chart(*args):
    start_price = args[0]
    mu, sigma, tck = args[1]
    days = 365
        
    for run in range(100):
        plt.plot(stock_monte_carlo(start_price, days, mu, sigma))

    plt.xlabel("Days")
    plt.ylabel("Price")
    plt.title("Analysis for {0}".format(tck))
    plt.show()
    plt.close()
    

start_price = AAPL['Adj Close'][0]
create_monte_chart(start_price, get_metrics('AAPL', rets))

start_price = FB['Adj Close'][0]
create_monte_chart(start_price, get_metrics('FB', rets))

start_price = AMZN['Adj Close'][0]
create_monte_chart(start_price, get_metrics('AMZN', rets))

start_price = GOOG['Adj Close'][0]
create_monte_chart(start_price, get_metrics('GOOG', rets))

rets.head()

start_price = FB['Adj Close'][0]

mu, sigma, tck = get_metrics('FB', rets)

simulations = run_simulations(start_price, mu, sigma)
plot_histogram(simulations, start_price, tck)

start_price = AAPL['Adj Close'][0]

mu, sigma, tck = get_metrics('AAPL', rets)

simulations = run_simulations(start_price, mu, sigma)
plot_histogram(simulations, start_price, tck)

start_price = AMZN['Adj Close'][0]

mu, sigma, tck = get_metrics('AMZN', rets)

simulations = run_simulations(start_price, mu, sigma)
plot_histogram(simulations, start_price, tck)

start_price = GOOG['Adj Close'][0]

mu, sigma, tck = get_metrics('GOOG', big4_returns)

simulations = run_simulations(start_price, mu, sigma)
plot_histogram(simulations, start_price, tck)