#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jul 30th 2025

@author: Marcel Weschke
@email: marcel.weschke@directbox.de
"""
# %% Load libraries
import os
import base64
import io
import datetime
from math import radians, sin, cos, sqrt, asin

import dash
from dash import dcc, html, Input, Output, Dash
import dash_bootstrap_components as dbc

import pandas as pd
import numpy as np
import plotly.express as px
import plotly.graph_objects as go
from scipy.interpolate import interp1d
import gpxpy


# === Helper Functions ===
def list_gpx_files():
    folder = './gpx_files'
    #return [{'label': f, 'value': os.path.join(folder, f)} for f in os.listdir(folder) if f.endswith('.gpx')]
    files = [f for f in os.listdir(folder) if f.endswith('.gpx')]

    # Extract date from the start of the filename and sort descending
    def extract_date(filename):
        try:
            return datetime.datetime.strptime(filename[:10], '%Y-%m-%d')
        except ValueError:
            return datetime.datetime.min  # Put files without a valid date at the end

    files.sort(key=extract_date, reverse=True)

    return [{'label': f, 'value': os.path.join(folder, f)} for f in files]



def haversine(lon1, lat1, lon2, lat2):
    R = 6371
    dlon = radians(lon2 - lon1)
    dlat = radians(lat2 - lat1)
    a = sin(dlat/2)**2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon/2)**2
    return 2 * R * asin(sqrt(a))


def process_gpx(file_path):
    with open(file_path, 'r') as gpx_file:
        gpx = gpxpy.parse(gpx_file)

    points = gpx.tracks[0].segments[0].points
    df = pd.DataFrame([{
        'lat': p.latitude,
        'lon': p.longitude,
        'elev': p.elevation,
        'time': p.time
    } for p in points])

    # Basic cleanup
    df['time'] = pd.to_datetime(df['time'])
    df['time_loc'] = df['time'].dt.tz_localize(None)
    df['time_diff'] = df['time'] - df['time'][0]
    df['time_diff_sec'] = df['time_diff'].dt.total_seconds()
    df['duration_hms'] = df['time_diff'].apply(lambda td: str(td).split('.')[0])
    # Cumulative distance (km)
    distances = [0]
    for i in range(1, len(df)):
        d = haversine(df.loc[i-1, 'lon'], df.loc[i-1, 'lat'], df.loc[i, 'lon'], df.loc[i, 'lat'])
        distances.append(distances[-1] + d)
    df['cum_dist_km'] = distances
    # Elevation and elevation change
    df['elev'] = df['elev'].bfill()
    df['delta_elev'] = df['elev'].diff().fillna(0)
    df['rel_elev'] = df['elev'] - df['elev'].iloc[0]
    # Velocity (used in pace and speed)
    df['vel_kmps'] = np.gradient(df['cum_dist_km'], df['time_diff_sec'])
    # Speed calculation (km/h) via distance and time diffs
    df['delta_t'] = df['time'].diff().dt.total_seconds()
    df['delta_d'] = df['cum_dist_km'].diff()
    df['speed_kmh'] = (df['delta_d'] / df['delta_t']) * 3600
    df['speed_kmh'] = df['speed_kmh'].replace([np.inf, -np.inf], np.nan)
    # Smoothed speed (Gaussian rolling)
    df['speed_kmh_smooth'] = df['speed_kmh'].rolling(window=10, win_type="gaussian", center=True).mean(std=2)

    return df


# =============================================================================
# INFO BANNER
# =============================================================================
def create_info_banner(df):
    # Total distance in km
    total_distance_km = df['cum_dist_km'].iloc[-1]

    # Total time as timedelta
    total_seconds = df['time_diff_sec'].iloc[-1]
    hours, remainder = divmod(int(total_seconds), 3600)
    minutes, seconds = divmod(remainder, 60)
    formatted_total_time = f"{hours:02d}:{minutes:02d}:{seconds:02d}"

    # Average pace (min/km)
    if total_distance_km > 0:
        pace_sec_per_km = total_seconds / total_distance_km
        pace_min = int(pace_sec_per_km // 60)
        pace_sec = int(pace_sec_per_km % 60)
        formatted_pace = f"{pace_min}:{pace_sec:02d} min/km"
    else:
        formatted_pace = "N/A"

    # Build the info banner layout
    info_banner = html.Div([
        html.Div([
            html.H4("Total Distance", style={'margin-bottom': '5px'}),
            html.H2(f"{total_distance_km:.2f} km")
        ], style={'width': '30%', 'display': 'inline-block', 'textAlign': 'center'}),

        html.Div([
            html.H4("Total Time", style={'margin-bottom': '5px'}),
            html.H2(formatted_total_time)
        ], style={'width': '30%', 'display': 'inline-block', 'textAlign': 'center'}),

        html.Div([
            html.H4("Average Pace", style={'margin-bottom': '5px'}),
            html.H2(formatted_pace)
        ], style={'width': '30%', 'display': 'inline-block', 'textAlign': 'center'}),
    ], style={
        'display': 'flex',
        'justifyContent': 'space-around',
        'backgroundColor': '#1e1e1e',
        'color': 'white',
        'padding': '20px',
        'marginBottom': '5px',
        'borderRadius': '10px',
        'width': '100%',
        #'maxWidth': '1200px',
        'margin': 'auto'
    })

    return info_banner
  

# =============================================================================
# START OF THE PLOTS
# =============================================================================
def create_map_plot(df):
    # fig = px.line_map(
    #     df,
    #     lat='lat',
    #     lon='lon',
    #     hover_name='time',
    #     hover_data={
    #         'cum_dist_km': ':.2f',
    #         'duration_hms': True,
    #         'lat': False,
    #         'lon': False,
    #         'time': False
    #     },
    #     labels={
    #         'cum_dist_km': 'Distance (km) ',
    #         'duration_hms': 'Elapsed Time '
    #     },
    #     zoom=13,
    #     height=800
    # )
    fig = px.line_map(
    df,
    lat='lat',
    lon='lon',
    zoom=13,
    height=800
    )
    
    fig.update_traces(
        hovertemplate=(
            #"Time: %{customdata[0]}<br>" +
            "Distance (km): %{customdata[1]:.2f}<br>" +
            "Elapsed Time: %{customdata[2]}<extra></extra>"
        ),
        customdata=df[['time', 'cum_dist_km', 'duration_hms']]
    )
    # Define map style and the line ontop
    fig.update_layout(map_style="open-street-map")
    # The built-in plotly.js styles are: carto-darkmatter, carto-positron, open-street-map, stamen-terrain, stamen-toner, stamen-watercolor, white-bg
    # The built-in Mapbox styles are: basic, streets, outdoors, light, dark, satellite, satellite-streets
    fig.update_traces(line=dict(color="#f54269", width=3))

    # Start / Stop marker
    start = df.iloc[0]
    end = df.iloc[-1]
    fig.add_trace(go.Scattermap(
        lat=[start['lat']], lon=[start['lon']], mode='markers+text',
        marker=dict(size=12, color='#fca062'), text=['Start'], name='Start', textposition='bottom left'
    ))
    fig.add_trace(go.Scattermap(
        lat=[end['lat']], lon=[end['lon']], mode='markers+text',
        marker=dict(size=12, color='#b9fc62'), text=['Stop'], name='Stop', textposition='bottom left'
    ))
    fig.update_layout(paper_bgcolor='#1e1e1e', font=dict(color='white'))
    fig.update_layout(
    legend=dict(
        orientation='h',         # horizontal layout
        yanchor='top',
        y=-0.01,                  # move legend below the map
        xanchor='center',
        x=0.5,
        font=dict(color='white')
    )
)
    return fig




######################
# NEUE VERSION:
def create_elevation_plot(df, smooth_points=500):
    # Originale Daten
    x = df['time']
    y = df['rel_elev']

    # Einfache Glättung: nur Y-Werte glätten, X-Werte beibehalten
    if len(y) >= 4:  # Genug Punkte für cubic interpolation
        y_numeric = y.to_numpy()

        # Nur gültige Y-Punkte für Interpolation
        mask = ~np.isnan(y_numeric)

        if np.sum(mask) >= 4:  # Genug gültige Punkte
            # Index-basierte Interpolation für Y-Werte
            valid_indices = np.where(mask)[0]
            valid_y = y_numeric[mask]

            # Interpolation über die Indizes
            f = interp1d(valid_indices, valid_y, kind='cubic',
                        bounds_error=False, fill_value='extrapolate')

            # Neue Y-Werte für alle ursprünglichen X-Positionen
            all_indices = np.arange(len(y))
            y_smooth = f(all_indices)

            # Originale X-Werte beibehalten
            x_smooth = x
        else:
            # Fallback: originale Daten
            x_smooth, y_smooth = x, y
    else:
        # Zu wenige Punkte: originale Daten verwenden
        x_smooth, y_smooth = x, y

    fig = go.Figure()

    # Fläche unter der Kurve (mit geglätteten Daten)
    fig.add_trace(go.Scatter(
        x=x_smooth, y=y_smooth,
        mode='lines',
        line=dict(color='#1CAF50'),      # Fill between color!
        fill='tozeroy',
        #fillcolor='rgba(226, 241, 248)',
        hoverinfo='skip',
        showlegend=False
    ))

    # Hauptlinie (geglättet)
    fig.add_trace(go.Scatter(
        x=x_smooth, y=y_smooth,
        mode='lines',
        line=dict(color='#084C20', width=2), # Line color!
        name='Elevation',
        showlegend=False
    ))

    # SUPDER IDEE, ABER GEHT NICHT WEGE NEUEN smoothed POINTS! GEHT NUR BEI X
    #fig.update_traces(
    #    hovertemplate=(
    #        #"Time: %{customdata[0]}<br>" +
    #        "Distance (km): %{customdata[0]:.2f}<br>" +
    #        "Elevation: %{customdata[1]}<extra></extra>" +
    #        "Elapsed Time: %{customdata[2]}<extra></extra>"
    #    ),
    #    customdata=df[['cum_dist_km','elev', 'time']]
    #

    # Layout im Dark Theme
    fig.update_layout(
        title=dict(text='Höhenprofil relativ zum Startwert', font=dict(size=16, color='white')),
        xaxis_title='Zeit',
        yaxis_title='Höhe relativ zum Start (m)',
        template='plotly_dark',
        paper_bgcolor='#1e1e1e',
        plot_bgcolor='#111111',
        font=dict(color='white'),
        margin=dict(l=40, r=40, t=50, b=40),
        height=400
    )

    return fig



def create_deviation_plot(df):  #Distanz-Zeit-Diagramm
    # Compute mean velocity in km/s
    vel_kmps_mean = df['cum_dist_km'].iloc[-1] / df['time_diff_sec'].iloc[-1]
    # Expected cumulative distance assuming constant mean velocity
    df['cum_dist_km_qmean'] = df['time_diff_sec'] * vel_kmps_mean
    # Deviation from mean velocity distance
    df['del_dist_km_qmean'] = df['cum_dist_km'] - df['cum_dist_km_qmean']
    # Plot the deviation
    fig = px.line(
        df,
        x='time_loc',
        y='del_dist_km_qmean',
        labels={
            'time_loc': 'Zeit',
            'del_dist_km_qmean': 'Δ Strecke (km)'
        },
        template='plotly_dark',
    )
    fig.update_layout(
        title=dict(text='Abweichung von integriertem Durchschnittstempo', font=dict(size=16)),
        yaxis_title='Abweichung (km)',
        xaxis_title='Zeit',
        height=400,
        paper_bgcolor='#1e1e1e',
        plot_bgcolor='#111111',
        font=dict(color='white', size=14),
        margin=dict(l=40, r=40, t=50, b=40)
    )
    # Add horizontal reference line at y=0
    fig.add_shape(
        type='line',
        x0=df['time_loc'].iloc[0],
        x1=df['time_loc'].iloc[-1],
        y0=0,
        y1=0,
        line=dict(color='gray', width=1, dash='dash'),
        name='Durchschnittstempo'
    )
    return fig


def create_speed_plot(df):
    mask = df['speed_kmh_smooth'].isna()
    mean_speed_kmh = df['speed_kmh'].mean()
    fig = go.Figure()
    fig.add_trace(go.Scatter(
        x=df['time'][~mask],
        y=df['speed_kmh_smooth'][~mask],
        mode='lines',
        name='Geglättete Geschwindigkeit',
        line=dict(color='royalblue')
    ))
    fig.update_layout(
        title=dict(text=f'Tempo über die Zeit (geglättet) - Durchschnittstempo: {mean_speed_kmh:.2f} km/h', font=dict(size=16)),
        xaxis=dict(title='Zeit', tickformat='%H:%M', type='date'),
        yaxis=dict(title='Geschwindigkeit (km/h)', rangemode='tozero'),
        template='plotly_dark',
        paper_bgcolor='#1e1e1e',
        plot_bgcolor='#111111',
        font=dict(color='white'),
        margin=dict(l=40, r=40, t=40, b=40)
    )
    # Add horizontal reference line at y=mean_speed_kmh
    fig.add_shape(
        type='line',
        x0=df['time_loc'].iloc[0],
        x1=df['time_loc'].iloc[-1],
        y0=mean_speed_kmh,
        y1=mean_speed_kmh,
        line=dict(color='gray', width=1, dash='dash'),
        name='Durchschnittstempo'
    )
    return fig



def create_pace_bars_plot(df):
    # Ensure time column is datetime
    if not pd.api.types.is_datetime64_any_dtype(df['time']):
        df['time'] = pd.to_datetime(df['time'], errors='coerce')

    # Assign km segments
    df['km'] = df['cum_dist_km'].astype(int)

    # Time in seconds from start
    df['time_sec'] = (df['time'] - df['time'].iloc[0]).dt.total_seconds()

    # Step 3: Compute pace manually per km group
    df['km_start'] = np.nan
    df['segment_len'] = np.nan
    df['pace_min_per_km'] = np.nan

    for km_val, group in df.groupby('km'):
        dist_start = group['cum_dist_km'].iloc[0]
        dist_end = group['cum_dist_km'].iloc[-1]
        segment_len = dist_end - dist_start

        time_start = group['time_sec'].iloc[0]
        time_end = group['time_sec'].iloc[-1]
        elapsed_time_sec = time_end - time_start

        if segment_len > 0:
            pace_min_per_km = (elapsed_time_sec / 60) / segment_len
        else:
            pace_min_per_km = np.nan

        df.loc[group.index, 'km_start'] = km_val
        df.loc[group.index, 'segment_len'] = segment_len
        df.loc[group.index, 'pace_min_per_km'] = pace_min_per_km

    # Clean types
    df['km_start'] = df['km_start'].astype(int)
    df['segment_len'] = df['segment_len'].astype(float)
    df['pace_min_per_km'] = pd.to_numeric(df['pace_min_per_km'], errors='coerce')

    # Step 4: Create Plotly bar chart
    fig = go.Figure()
    fig.add_trace(go.Bar(
        x=df['km_start'],
        y=df['pace_min_per_km'],
        width=df['segment_len'],
        text=[f"{v:.1f} min/km" if pd.notnull(v) else "" for v in df['pace_min_per_km']],
        textposition='outside',
        marker_color='dodgerblue',
        name='Pace pro km',
        offset=0
    ))




    # #########
    # Add horizontal reference line - X-Werte für gesamte Breite
    # Calculate average pace
    total_distance_km = df['cum_dist_km'].iloc[-1]
    total_seconds = df['time_diff_sec'].iloc[-1]

    # Average pace (min/km) - KORRIGIERT
    if total_distance_km > 0:
        pace_sec_per_km = total_seconds / total_distance_km
        pace_min_per_km = pace_sec_per_km / 60  # Konvertiere zu Minuten pro km
    else:
        pace_min_per_km = 0

    fig.add_shape(
        type='line',
        x0=0,  # Start bei 0
        x1=total_distance_km,  # Ende bei maximaler Distanz
        y0=pace_min_per_km,
        y1=pace_min_per_km,
        line=dict(color='gray', width=1, dash='dash'),
    )

    ## Optional: Text-Annotation für die durchschnittliche Pace
    #fig.add_annotation(
    #    x=total_distance_km * 0.8,  # Position bei 80% der Distanz
    #    y=pace_min_per_km,
    #    text=f"Ø {pace_min_per_km:.1f} min/km",
    #    showarrow=True,
    #    arrowhead=2,
    #    arrowcolor="gray",
    #    bgcolor="rgba(255,0,0,0.1)",
    #    bordercolor="gray",
    #    font=dict(color="white")
    #)




    fig.update_layout(
        title=dict(text='Tempo (min/km) je Kilometer', font=dict(size=16)),
        xaxis_title='Distanz (km)',
        yaxis_title='Minuten pro km',
        barmode='overlay',
        bargap=0,
        bargroupgap=0,
        xaxis=dict(
            type='linear',
            range=[0, df['cum_dist_km'].iloc[-1]],
            tickmode='linear',
            dtick=1,
            showgrid=True
        ),
        template='plotly_dark',
        height=400,
        margin=dict(l=40, r=40, t=30, b=40),
        plot_bgcolor='#111111',
        paper_bgcolor='#1e1e1e',
        font=dict(color='white')
    )
    return fig





# === App Setup ===
app = dash.Dash(__name__, external_stylesheets=[dbc.themes.SLATE])
app.title = "GPX Dashboard"

app.layout = html.Div([
    html.H1("Running Dashboard", style={'textAlign': 'center'}),
    dcc.Store(id='stored-df'),

    html.Div([
        html.Label("GPX-Datei wählen:", style={'color': 'white'}),
        dcc.Dropdown(
            id='gpx-file-dropdown',
            options=list_gpx_files(),
            value=list_gpx_files()[0]['value'],
            clearable=False,
            style={'width': '300px', 'color': 'black'}
        )
    ], style={'padding': '20px', 'backgroundColor': '#1e1e1e'}),

    html.Div(id='info-banner'),
    dcc.Graph(id='fig-map'),
    dcc.Graph(id='fig-elevation'),
    dcc.Graph(id='fig_deviation'),
    dcc.Graph(id='fig_speed'),
    dcc.Graph(id='fig_pace_bars')
])


# === Callbacks ===
# Callback 1: Load GPX File and Store as JSON
@app.callback(
    Output('stored-df', 'data'),
    Input('gpx-file-dropdown', 'value')
)
def load_gpx_data(path):
    df = process_gpx(path)
    return df.to_json(date_format='iso', orient='split')

# Callback 2: Update All Plots
@app.callback(
    Output('info-banner', 'children'),
    Output('fig-map', 'figure'),
    Output('fig-elevation', 'figure'),
    Output('fig_deviation', 'figure'),
    Output('fig_speed', 'figure'),
    Output('fig_pace_bars', 'figure'),
    Input('stored-df', 'data')
)
def update_all_plots(json_data):
    df = pd.read_json(io.StringIO(json_data), orient='split')

    info = create_info_banner(df)
    fig_map = create_map_plot(df)
    fig_elev = create_elevation_plot(df)
    fig_dev = create_deviation_plot(df)
    fig_speed = create_speed_plot(df)
    fig_pace = create_pace_bars_plot(df)

    return info, fig_map, fig_elev, fig_dev, fig_speed, fig_pace


# === Run Server ===
if __name__ == '__main__':
    app.run(debug=True, port=8051)

    
# NOTE:
#    Zusammenhang zwischen Pace und Geschwindigkeit
#     - Pace = Minuten pro Kilometer (z. B. 5:40/km)
#     - Geschwindigkeit = Kilometer pro Stunde (z. B. 10.71 km/h)
#