import datetime as dt
import pytz

import numpy as np
import pandas as pd
import xml.etree.ElementTree
import json
import requests

import pyproj
import geopandas as gpd
from shapely.geometry import Point
from shapely.wkt import loads

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

from bokeh.io import output_file, output_notebook, show
from bokeh.models import (
  GMapPlot, GMapOptions, ColumnDataSource, Circle, LogColorMapper, BasicTicker, ColorBar,
    DataRange1d, Range1d, PanTool, WheelZoomTool, BoxSelectTool, ResetTool
)
from bokeh.models.mappers import ColorMapper, LinearColorMapper
from bokeh.palettes import Viridis5
from bokeh.plotting import figure
from bokeh.resources import CDN
from bokeh.embed import file_html

from lib import custom_utils

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())

runkeeper_runs = pd.read_csv('data/01-runkeeper-data-export-2019-01-09-162557/cardioActivities.csv', parse_dates=[1])
runkeeper_runs.head()

# ignore runs with invalid pace
runkeeper_runs = runkeeper_runs.dropna(subset=['Average Pace'])

# convert duration strings to timedeltas
runkeeper_runs['Average Pace'] = runkeeper_runs['Average Pace'].apply(custom_utils.duration_to_delta)
runkeeper_runs['Duration'] = runkeeper_runs['Duration'].apply(custom_utils.duration_to_delta)

# add column with pace in seconds
runkeeper_runs['avg_pace_secs'] = runkeeper_runs['Average Pace'].dt.total_seconds()

# ignore crazy outliers with pace >15 minutes (I sometimes forget to end the run)
runkeeper_runs = runkeeper_runs[runkeeper_runs['avg_pace_secs']/60 < 15].reset_index(drop=True)

dow_to_str = {0: 'Mon', 1: 'Tue', 2: 'Wed', 3: 'Thu', 4: 'Fri', 5: 'Sat', 6: 'Sun'}

runkeeper_runs['dow'] = runkeeper_runs['Date'].dt.dayofweek
pace_dow_avgs = runkeeper_runs.groupby(['dow'])['avg_pace_secs'].mean()

data = []
data.append(
    go.Bar(
        x=pace_dow_avgs.keys(),
        y=pace_dow_avgs.values / 60,
        name='Pace Averages'
    )
)

layout = go.Layout(
    title='Average Pace vs Day of Week',
    barmode='group',
    xaxis={
        'title': 'Day of Week (0=Mon)'
    },
    yaxis={
        'title': 'Minutes'
    }
)

fig = go.Figure(data=data, layout=layout)
iplot(fig, filename='DOW avg')

data = []
for i, dow in enumerate(sorted(runkeeper_runs['dow'].unique())):
    # get pace histogram, ignoring outliers
    pace_vals = runkeeper_runs[runkeeper_runs['dow'] == dow]['avg_pace_secs'].value_counts()
    
    data.append(
        go.Bar(
            x=pace_vals.keys() / 60,
            y=pace_vals.values,
            name=str(dow),
            yaxis='y' + str(i+1)
        )
    )

fig = tools.make_subplots(rows=4, cols=2, subplot_titles=[dow_to_str[day] for day in sorted(runkeeper_runs['dow'].unique())])

fig.append_trace(data[0], 1, 1)
fig.append_trace(data[1], 1, 2)
fig.append_trace(data[2], 2, 1)
fig.append_trace(data[3], 2, 2)
fig.append_trace(data[4], 3, 1)
fig.append_trace(data[5], 3, 2)
fig.append_trace(data[6], 4, 1)

for i, sem in enumerate(sorted(runkeeper_runs['dow'].unique())):
    fig['layout']['xaxis' + str(i+1)].update(range=[7, 10])
    fig['layout']['yaxis' + str(i+1)].update(range=[0, 3])

fig.layout.update(height=1000)
fig.layout.update(title='Pace Distibution by Day of Week')

iplot(fig, filename='dow pace')

early_avg = runkeeper_runs[runkeeper_runs['Date'].dt.hour < 9]['avg_pace_secs'].mean()
morn_avg = runkeeper_runs[(runkeeper_runs['Date'].dt.hour >= 9) & (runkeeper_runs['Date'].dt.hour < 12)]['avg_pace_secs'].mean()
after_avg = runkeeper_runs[(runkeeper_runs['Date'].dt.hour >= 12) & (runkeeper_runs['Date'].dt.hour < 7)]['avg_pace_secs'].mean()
night_avg = runkeeper_runs[runkeeper_runs['Date'].dt.hour >= 7]['avg_pace_secs'].mean()

data = []
data.append(
    go.Bar(
        x=['Early Morning', 'Morning', 'Afternoon', 'Night'],
        y=[early_avg / 60, morn_avg / 60, after_avg / 60, night_avg / 60],
        name='Pace Avgs'
    )
)

layout = go.Layout(
    title='Average Pace vs Time of Day',
    barmode='group',
    xaxis={
        'title': 'Time of Day'
    },
    yaxis={
        'title': 'Minutes'
    }
)

fig = go.Figure(data=data, layout=layout)
iplot(fig, filename='tod pace')

x = []
y = []
for i in range(5):
    x.append(str(i) + ' <= Miles < ' + str(i+1))
    y.append(runkeeper_runs[(runkeeper_runs['Distance (mi)'] >= i) & (runkeeper_runs['Distance (mi)'] < i+1)]['avg_pace_secs'].mean() / 60) 

data = []
data.append(
    go.Bar(
        x=x,
        y=y,
        name='Mile Averages'
    )
)

layout = go.Layout(
    title='Average Pace vs Run Distance',
    barmode='group',
    xaxis={
        'title': 'Length of Run'
    },
    yaxis={
        'title': 'Minutes'
    }
)

fig = go.Figure(data=data, layout=layout)
iplot(fig, filename='distance pace')

rr_date_sorted = runkeeper_runs.sort_values('Date').reset_index()

row_mask = (rr_date_sorted['Date'] - rr_date_sorted['Date'].shift(1)).dt.total_seconds()/3600 < 36

data = []
data.append(
    go.Bar(
        x=['Ran 36 Hrs Before', 'Didn\'t Run 36 Hrs Before'],
        y=[rr_date_sorted[row_mask]['avg_pace_secs'].mean()/60, rr_date_sorted[~row_mask]['avg_pace_secs'].mean()/60],
        name='Paces'
    )
)

layout = go.Layout(
    title='Average Pace vs If I Ran 36 hours Before',
    barmode='group',
    yaxis={
        'title': 'Minutes'
    }
)

fig = go.Figure(data=data, layout=layout)
iplot(fig, filename='ran before pace')

def get_town(lat, lon):
    url = "https://maps.googleapis.com/maps/api/geocode/json?"
    url += "latlng=%s,%s&sensor=false&key=%s" % (lat, lon, keys['google_geocoding_api_key'])
    v = requests.get(url)
    j = json.loads(v.text)
    components = j['results'][0]['address_components']
    town = state = None
    for c in components:
        if "locality" in c['types']:
            town = c['long_name']
        elif "administrative_area_level_1" in c['types']:
            state = c['short_name']

    return town+', '+state if state else "Unknown"

_GEOD = pyproj.Geod(ellps='WGS84')

all_meas = []
locations = []

for index, gpx_filename in enumerate(runkeeper_runs['GPX File']):
    # build path
    gpx_filepath = 'data/01-runkeeper-data-export-2019-01-09-162557/'+gpx_filename
    
    # load gpx
    root = xml.etree.ElementTree.parse(gpx_filepath).getroot()
    
    # get loop through all points
    meas = []
    for trkseg in root[0].findall('{http://www.topografix.com/GPX/1/1}trkseg'):
        for point in trkseg:
            # get data from point
            lat, lon = float(point.get('lat')), float(point.get('lon'))
            ele = float(point[0].text)
            timestamp = dt.datetime.strptime(point[1].text, '%Y-%m-%dT%H:%M:%SZ')
            
            if not meas:
                # add first point
                v = 0
                locations.append(get_town(lat, lon))
                time_from_start = 0
            else:
                # calculate distance
                # Source: https://stackoverflow.com/questions/24968215/python-calculate-speed-distance-direction-from-2-gps-coordinates
                try:
                    # inv returns azimuth, back azimuth and distance
                    _, _ , d = _GEOD.inv(meas[-1]['lon'], meas[-1]['lat'], lon, lat) 
                except:
                    raise ValueError("Invalid MGRS point")
                
                # calculate time different
                t = ( (timestamp - meas[-1]['timestamp']).total_seconds() )
                
                # calculate speed (m/s)
                if t == 0:
                    continue
                
                # speed in meters per second
                v = d / t
                
                time_from_start = (timestamp - meas[0]['timestamp']).total_seconds()
                
            # append point
            meas.append({
                'timestamp': timestamp,
                'lat': lat,
                'lon': lon,
                'ele': ele,
                'location': locations[index],
                'speed': v*2.23694, # mph
                'run_idx': int(index),
                'time_from_start': time_from_start
            })
    
    # add this run's points to all points
    all_meas.extend(meas)


all_meas = pd.DataFrame(all_meas)

all_meas.speed.iplot(kind='histogram', bins=100)