import datetime as dt
import pytz

import numpy as np
import pandas as pd
import json
import requests

from lib.python_fitbit import fitbit
from lib.python_fitbit import gather_keys_oauth2 as Oauth2

from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
import plotly.graph_objs as go
from plotly import tools
import cufflinks as cf

init_notebook_mode(connected=True)
cf.set_config_file(world_readable=True, offline=True)

with open('keys.json', 'r') as f:
    keys = json.loads(f.read())

server = Oauth2.OAuth2Server(keys['fitbit_client_id'], keys['fitbit_client_secret'])
server.browser_authorize()
ACCESS_TOKEN = str(server.fitbit.client.session.token['access_token'])
REFRESH_TOKEN = str(server.fitbit.client.session.token['refresh_token'])
fitbit_client = fitbit.Fitbit(keys['fitbit_client_id'], keys['fitbit_client_secret'], oauth2=True, access_token=ACCESS_TOKEN, refresh_token=REFRESH_TOKEN)

all_activities = []

# create url manually because not supported by sdk
base_url = "{0}/{1}/user/{2}/activities/list.json?afterDate={3}&sort=asc&limit=20&offset=0"
url = base_url.format(*fitbit_client._get_common_args(None), '2019-01-01')
activities_list = fitbit_client.make_request(url, method='GET')

all_activities.extend(activities_list['activities'])

# api returns <=20 activities, check for more
while activities_list['pagination']['next']:
    # get next list of activities
    next_url = activities_list['pagination']['next']
    activities_list = fitbit_client.make_request(next_url, method='GET')
    
    if len(activities_list['activities']) > 0:
        all_activities.extend(activities_list['activities'])
    
activities = pd.DataFrame(all_activities)
fitbit_runs = activities[activities['activityName'].str.contains("Run")].reset_index(drop=True)
fitbit_runs['startTime'] = pd.to_datetime(fitbit_runs['startTime']).dt.tz_localize('UTC')
fitbit_runs.head()

hr_for_run = []
steps_for_run = []
for index, run in fitbit_runs.iterrows():
    # add buffer to heart rate api url
    hr_link = run['heartRateLink']
    hr_link_split = hr_link.split('/')
    
    start_time_str = hr_link_split[-2]
    end_time_str = hr_link_split[-1].split('.')[0]
    
    start_time = dt.datetime.strptime(start_time_str, '%H:%M:%S')
    start_time = start_time - dt.timedelta(minutes=10)
    
    end_time = dt.datetime.strptime(end_time_str, '%H:%M:%S')
    end_time = end_time + dt.timedelta(minutes=45)
    
    hr_link = '/'.join(hr_link_split[:-2]) + '/' + start_time.strftime('%H:%M:%S') + '/' + end_time.strftime('%H:%M:%S') + '.json'
    
    # get heart rate data
    heart_info = fitbit_client.make_request(hr_link, method='GET')
    
    # heart rate data to df
    hr_df = pd.DataFrame(heart_info['activities-heart-intraday']['dataset'])
    hr_df.time = pd.to_datetime(hr_df.time)
    hr_df['time_from_start'] = hr_df.time - hr_df.time.iloc[0]
    
    hr_for_run.append(hr_df)
    
    # get steps for that day
    start_time = run['startTime'].to_pydatetime()
    steps_info = fitbit_client.intraday_time_series('activities/steps', base_date=start_time.strftime('%Y-%m-%d'), detail_level='1min')
    
    # step data to df
    steps_df = pd.DataFrame(steps_info['activities-steps-intraday']['dataset'])
    steps_df.time = start_time.strftime('%Y-%m-%d') + ' ' + steps_df.time
    steps_df.time = pd.to_datetime(steps_df.time).dt.tz_localize('EST')
    
    # get step data from 10 minutes before run start to 30 minutes after run start
    steps_df = steps_df[(steps_df.time > run.startTime - dt.timedelta(minutes=10)) & (steps_df.time < (run.startTime + dt.timedelta(minutes=30)))]
    steps_df['time_from_start'] = steps_df.time - steps_df.time.iloc[10]
    
    steps_for_run.append(steps_df)

# label each run with its month
fitbit_runs['month'] = fitbit_runs['startTime'].dt.month

data = []
for month in sorted(fitbit_runs.month.value_counts().keys()):
    # get that month's runs idx
    run_idx = fitbit_runs[fitbit_runs.month == month].index
    
    # find average hr recovery for that month
    seconds_from_start = range(0, 60*40, 5)
    hrs = {key: [] for key in seconds_from_start}
    
    for i in run_idx:
        # skip short runs for better averages
        if fitbit_runs.iloc[i].duration < 600000: continue
        
        # beginning of run
        recovery_start = hr_for_run[i].iloc[0].time_from_start
        
        # query hr
        for seconds in seconds_from_start:
            # find 5 second interval 
            start_delta = recovery_start + dt.timedelta(seconds=seconds)
            end_delta = start_delta + dt.timedelta(seconds=5)

            val = hr_for_run[i][(hr_for_run[i].time_from_start >= start_delta) & (hr_for_run[i].time_from_start <= end_delta)].value
            
            hrs[seconds].extend(val.values)
    
    avg_hrs = {}
    for seconds, hrs in hrs.items():
        if hrs:
            avg_hrs[seconds] = np.mean(hrs)
        else:
            # no hr recorded for interval, use previous interval
            avg_hrs[seconds] = avg_hrs[seconds-5]
            
    xvals = np.array(range(60*-10, 60*35, 5))/60
    yvals = list(avg_hrs.values())
    
    data.append(go.Scatter(
        x=xvals,
        y=yvals,
        name=dt.date(1900, month, 1).strftime('%B'),
        visible="legendonly"
    ))
    
    data.append(go.Scatter(
        x=xvals,
        y=pd.Series(yvals).rolling(window=24).mean().iloc[24-1:].values,
        name=dt.date(1900, month, 1).strftime('%B') + ' 2min SMA',
    ))

layout = go.Layout(
    title='Heart Rate during Run',
    xaxis=dict(
        title='Minutes from Fitbit-Recorded Start of Run'
    ),
    yaxis=dict(
        title='Heart Rate',
        range=[60, 175]
    )
)

fig = go.Figure(data=data, layout=layout)
iplot(fig, filename='hr-by-run')

data = []
for month in sorted(fitbit_runs.month.value_counts().keys()):
    # get that month's runs idx
    run_idx = fitbit_runs[fitbit_runs.month == month].index
    
    # find average hr recovery for that month
    seconds_from_start_of_recovery = range(0, 60*7, 5)
    hrs = {key: [] for key in seconds_from_start_of_recovery}
    
    for i in run_idx:
        if hr_for_run[i][hr_for_run[i].value > 160].empty: continue
        
        # find time 3 minutes before heart rate went below 160
        recovery_start = hr_for_run[i][hr_for_run[i].value > 160].iloc[-1].time_from_start - dt.timedelta(seconds=180)
        
        # query hr through 45 minutes after start of recovery
        for seconds in seconds_from_start_of_recovery:
            # find 5 second interval 
            start_delta = recovery_start + dt.timedelta(seconds=seconds)
            end_delta = start_delta + dt.timedelta(seconds=5)

            val = hr_for_run[i][(hr_for_run[i].time_from_start >= start_delta) & (hr_for_run[i].time_from_start <= end_delta)].value
            
            hrs[seconds].extend(val.values)
    
    avg_hrs = {}
    for seconds, hrs in hrs.items():
        if hrs:
            avg_hrs[seconds] = np.mean(hrs)
        else:
            # no hr recorded for interval, use previous interval
            avg_hrs[seconds] = avg_hrs[seconds-5]
            
    xvals = np.array(list(avg_hrs.keys()))/60
    yvals = list(avg_hrs.values())
    
    data.append(go.Scatter(
        x=xvals,
        y=yvals,
        name=dt.date(1900, month, 1).strftime('%B'),
        visible="legendonly"
    ))
    
    data.append(go.Scatter(
        x=xvals,
        y=pd.Series(yvals).rolling(window=6).mean().iloc[24-1:].values,
        name=dt.date(1900, month, 1).strftime('%B') + ' 30sec SMA',
    ))

layout = go.Layout(
    title='Heart Rate Recovery by Month',
    xaxis=dict(
        title='Minutes from Start of Recovery (3 Minutes before Heart Rate went below 160)'
    ),
    yaxis=dict(
        title='Heart Rate',
        range=[100, 175]
    )
)

fig = go.Figure(data=data, layout=layout)
iplot(fig, filename='hr-recovery-by-month')

# get min amount of data for run
step_len = np.min([len(steps) for steps in steps_for_run])

# assemble runs into matrix
steps_for_run_mat = np.ones((len(steps_for_run), step_len))
for i in range(len(steps_for_run)):
    steps_for_run_mat[i][:] = steps_for_run[i].value[:step_len]

data = []
for month in sorted(fitbit_runs.month.value_counts().keys()):
    # get that month's runs idx
    run_idx = fitbit_runs[fitbit_runs.month == month].index
    month_runs = steps_for_run_mat[run_idx]
    
    # get runs that recorded valid amount of steps
    month_runs = month_runs[np.argwhere(month_runs.mean(axis=1) > 50).reshape(-1)]

    data.append(go.Scatter(
            x=steps_for_run[0].time_from_start.dt.total_seconds() / 60,
            y=month_runs.mean(axis=0),
            name=dt.date(1900, month, 1).strftime('%B')
        ))

layout = go.Layout(
    title='Steps per Minute during Run',
    xaxis=dict(
        title='Minutes from Fitbit-Recorded Start of Run'
    ),
    yaxis=dict(
        title='Steps'
    )
)

fig = go.Figure(data=data, layout=layout)
iplot(fig, filename='steps-by-run')