#!/usr/bin/env python
# coding: utf-8

# # Python Crypto Assignment 2: Predict Crypto Price Data using Regeration

# ### import modules

# In[1]:


import requests
import datetime
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf


# In[2]:


def daily_price_historical(symbol, comparison_symbol, all_data=False, limit=1, aggregate=1, exchange=''):
    url = 'https://min-api.cryptocompare.com/data/histoday?fsym={}&tsym={}&limit={}&aggregate={}'\
            .format(symbol.upper(), comparison_symbol.upper(), limit, aggregate)
    if exchange:
        url += '&e={}'.format(exchange)
    if all_data:
        url += '&allData=true'
    page = requests.get(url)
    data = page.json()['Data']
    df = pd.DataFrame(data)
    df['timestamp'] = [datetime.datetime.fromtimestamp(d) for d in df.time]
    return df


# In[3]:


df = daily_price_historical('BTC', 'USD', all_data=True)
msk = np.random.rand(len(df)) < 0.8
train = df[msk]
test = df[~msk]


# In[4]:


print (len(train), len(test))
print (train, test)


# In[5]:


plt.figure(figsize=(20,10))
plt.plot(train.timestamp, train.high)
plt.title('BTC' + ' To ' + 'USD', fontsize=24)
plt.ylabel('Train Data In ' + 'USD', fontsize=18)
plt.xlabel('Year', fontsize=18)
plt.show()


# In[6]:


plt.figure(figsize=(20,10))
plt.plot(test.timestamp, test.high)
plt.title('BTC' + ' To ' + 'USD', fontsize=24)
plt.ylabel('Test Data In ' + 'USD', fontsize=18)
plt.xlabel('Year', fontsize=18)
plt.show()


# In[7]:


np.set_printoptions(suppress=True)
train_X = np.asarray(train.time)
train_Y = np.asarray(train.high)
# np.set_printoptions(suppress=True)
# train_X = np.asarray([float(10000*np.random.random()) for i in xrange(4)]).astype(int)
# train_Y = train_X * 1.5


# In[8]:


# Parameters
learning_rate = 0.000000000000001
training_epochs = 1
display_step = 50


# In[9]:


# tf Graph Input
X = tf.placeholder("float")
Y = tf.placeholder("float")

# Set model weights
W = tf.Variable(0., name="weight")
b = tf.Variable(0., name="bias")


# In[10]:


# Construct a linear model
pred = tf.add(tf.multiply(X, W), b)


# In[11]:


n_samples = train_X.shape[0]

print ( train_Y, train_X)
# Mean squared error
powa = (pred-Y) * (pred-Y)
cost = tf.reduce_sum(powa)/(2*n_samples)
# Gradient descent
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)


# In[12]:


# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()


# In[13]:


# Start training
with tf.Session() as sess:
    sess.run(init)

    # Fit all training data
    for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            sess.run(optimizer, feed_dict={X: x, Y: y})
            print '-----------------------------------------'
            print ('pred', sess.run(pred, feed_dict={X: x, Y: y}))
            print ('W', sess.run(W))
            print ('X', sess.run(X, feed_dict={X: x, Y: y}))
            print ('b', sess.run(b))
            print ('y', y)
            print ('powa', sess.run(powa, feed_dict={X: x, Y: y}))
            print '-----------------------------------------'


        #Display logs per epoch step
        if (epoch+1) % display_step == 0:
            c = sess.run(cost, feed_dict={X: train_X, Y: train_Y})
            print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c), \
                "W=", sess.run(W), "b=", sess.run(b)

    print "Optimization Finished!"
    training_cost = sess.run(cost, feed_dict={X: train_X, Y: train_Y})
    print "Training cost=", training_cost, "W=", sess.run(W), "b=", sess.run(b), '\n'

    #Graphic display
    plt.plot(train_X, train_Y, 'ro', label='Original data')
    plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
    plt.legend()
    plt.show()


# In[ ]:





# In[ ]:





# In[ ]:





# In[ ]:





# In[ ]:





# In[ ]: