Program.cs

using System;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;
using System.Xml.Linq;
using Microsoft.Extensions.Configuration;
using StravaCloner.Models;

namespace StravaCloner
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var config = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .Build();

            string? clientId = config["Strava:ClientId"];
            string? clientSecret = config["Strava:ClientSecret"];
            string? refreshToken = config["Strava:RefreshToken"];

            if (string.IsNullOrEmpty(clientId) || clientId == "YOUR_CLIENT_ID")
            {
                Console.WriteLine("Please configure your Strava API keys in appsettings.json");
                return;
            }

            Console.WriteLine("Getting Strava Access Token...");
            string? accessToken = await GetAccessToken(clientId, clientSecret, refreshToken);
            if (string.IsNullOrEmpty(accessToken))
            {
                Console.WriteLine("Failed to get Access Token. Exiting.");
                return;
            }
            Console.WriteLine("Successfully authenticated!");

            Console.WriteLine();
            string gpxDirectory = Path.Combine(Directory.GetCurrentDirectory(), "GPX");
            
            if (!Directory.Exists(gpxDirectory))
            {
                Console.WriteLine($"GPX directory not found at: {gpxDirectory}. Please create it and add your GPX files.");
                return;
            }

            var gpxFiles = Directory.GetFiles(gpxDirectory, "*.gpx");
            if (gpxFiles.Length == 0)
            {
                Console.WriteLine($"No .gpx files found in the directory: {gpxDirectory}");
                return;
            }

            Console.WriteLine("Available GPX files:");
            for (int i = 0; i < gpxFiles.Length; i++)
            {
                Console.WriteLine($"[{i + 1}] {Path.GetFileName(gpxFiles[i])}");
            }

            Console.Write("\nEnter the number of the GPX file you want to upload: ");
            string? selectionStr = Console.ReadLine();
            
            if (!int.TryParse(selectionStr, out int selectedIndex) || selectedIndex < 1 || selectedIndex > gpxFiles.Length)
            {
                Console.WriteLine("Invalid selection. Exiting.");
                return;
            }

            string gpxPath = gpxFiles[selectedIndex - 1];
            Console.WriteLine($"Selected file: {Path.GetFileName(gpxPath)}");
            Console.WriteLine();

            Console.Write("Enter the new start timestamp (e.g., yyyy-MM-dd HH:mm:ss): ");
            string? timeString = Console.ReadLine();

            if (!DateTime.TryParse(timeString, out DateTime newStartTime))
            {
                Console.WriteLine("Invalid timestamp format.");
                return;
            }

            // Convert to UTC as GPX typically stores UTC time
            newStartTime = newStartTime.ToUniversalTime();

            Console.Write("Enter a device name (e.g., Garmin Edge 530) or press Enter to keep original: ");
            string? deviceName = Console.ReadLine();

            Console.WriteLine($"Processing GPX file...");
            string? newGpxPath = ProcessGpxFile(gpxPath, newStartTime, deviceName);
            
            if (string.IsNullOrEmpty(newGpxPath))
            {
                return;
            }

            Console.WriteLine($"GPX timestamps shifted. Modified file saved to: {newGpxPath}");
            Console.WriteLine("Uploading to Strava...");

            await UploadToStrava(accessToken, newGpxPath);
            
            // Clean up temporary file
            // if (File.Exists(newGpxPath))
            // {
            //     File.Delete(newGpxPath);
            // }

            Console.WriteLine("Done.");
        }

        static async Task<string?> GetAccessToken(string? clientId, string? clientSecret, string? refreshToken)
        {
            using var client = new HttpClient();
            var values = new System.Collections.Generic.Dictionary<string, string>
            {
                { "client_id", clientId ?? "" },
                { "client_secret", clientSecret ?? "" },
                { "grant_type", "refresh_token" },
                { "refresh_token", refreshToken ?? "" }
            };

            var content = new FormUrlEncodedContent(values);
            var response = await client.PostAsync("https://www.strava.com/oauth/token", content);

            if (response.IsSuccessStatusCode)
            {
                var responseString = await response.Content.ReadAsStringAsync();
                var tokenResponse = JsonSerializer.Deserialize<StravaTokenResponse>(responseString);
                return tokenResponse?.AccessToken;
            }
            
            Console.WriteLine($"Error getting token: {response.StatusCode}");
            string errorBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(errorBody);
            return null;
        }

        static string? ProcessGpxFile(string filePath, DateTime newStartTime, string? deviceName)
        {
            try
            {
                XDocument gpxDoc = XDocument.Load(filePath);
                
                if (!string.IsNullOrWhiteSpace(deviceName) && gpxDoc.Root != null)
                {
                    var creatorAttr = gpxDoc.Root.Attribute("creator");
                    if (creatorAttr != null)
                    {
                        creatorAttr.Value = deviceName;
                    }
                    else
                    {
                        gpxDoc.Root.Add(new XAttribute("creator", deviceName));
                    }
                }

                XNamespace? ns = gpxDoc.Root?.GetDefaultNamespace() ?? XNamespace.None;

                // Find the first time element to calculate the shift required
                var firstTimeElement = gpxDoc.Descendants(ns + "time").FirstOrDefault();
                if (firstTimeElement == null)
                {
                    Console.WriteLine("No <time> elements found in the GPX file.");
                    return null;
                }

                if (!DateTime.TryParse(firstTimeElement.Value, out DateTime originalStartTime))
                {
                    Console.WriteLine($"Could not parse the original start time: {firstTimeElement.Value}");
                    return null;
                }
                
                // Ensure original time is UTC for correct mathematical difference
                originalStartTime = originalStartTime.ToUniversalTime();

                TimeSpan timeShift = newStartTime - originalStartTime;
                Console.WriteLine($"Original Start: {originalStartTime:O}");
                Console.WriteLine($"New Start:      {newStartTime:O}");
                Console.WriteLine($"Time Shift:     {timeShift}");

                // Shift all time elements
                foreach (var timeElement in gpxDoc.Descendants(ns + "time"))
                {
                    if (DateTime.TryParse(timeElement.Value, out DateTime currentTime))
                    {
                        DateTime shiftedTime = currentTime.ToUniversalTime() + timeShift;
                        // GPX standard prefers ISO 8601 with 'Z' for UTC
                        timeElement.Value = shiftedTime.ToString("yyyy-MM-ddTHH:mm:ssZ");
                    }
                }

                string newPath = Path.Combine(Path.GetDirectoryName(filePath) ?? "", $"shifted_{Path.GetFileName(filePath)}");
                gpxDoc.Save(newPath);
                return newPath;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error processing GPX file: {ex.Message}");
                return null;
            }
        }

        static async Task UploadToStrava(string accessToken, string filePath)
        {
            using var client = new HttpClient();
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);

            using var form = new MultipartFormDataContent();
            
            // Add the file content
            using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
            using var streamContent = new StreamContent(fileStream);
            streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
            form.Add(streamContent, "file", Path.GetFileName(filePath));

            // Add required metadata
            form.Add(new StringContent("gpx"), "data_type");

            Console.WriteLine("Sending file to Strava /uploads endpoint...");
            var response = await client.PostAsync("https://www.strava.com/api/v3/uploads", form);
            var responseString = await response.Content.ReadAsStringAsync();

            if (!response.IsSuccessStatusCode)
            {
                Console.WriteLine($"Upload failed with status {response.StatusCode}");
                Console.WriteLine(responseString);
                return;
            }

            var uploadResponse = JsonSerializer.Deserialize<StravaUploadResponse>(responseString);
            Console.WriteLine($"Upload created successfully. Upload ID: {uploadResponse?.Id}");
            
            await PollUploadStatus(client, uploadResponse?.Id ?? 0);
        }

        static async Task PollUploadStatus(HttpClient client, long uploadId)
        {
            if (uploadId == 0) return;

            Console.WriteLine("Polling for processing status...");
            bool isProcessing = true;

            while (isProcessing)
            {
                await Task.Delay(3000); // Poll every 3 seconds

                var response = await client.GetAsync($"https://www.strava.com/api/v3/uploads/{uploadId}");
                var responseString = await response.Content.ReadAsStringAsync();

                if (response.IsSuccessStatusCode)
                {
                    var status = JsonSerializer.Deserialize<StravaUploadResponse>(responseString);
                    Console.WriteLine($"Status: {status?.Status}");

                    if (!string.IsNullOrEmpty(status?.Error))
                    {
                        Console.WriteLine($"Error during processing: {status.Error}");
                        isProcessing = false;
                    }
                    else if (status?.ActivityId != null)
                    {
                        Console.WriteLine($"Activity successfully created! Activity ID: {status.ActivityId}");
                        Console.WriteLine($"View at: https://www.strava.com/activities/{status.ActivityId}");
                        isProcessing = false;
                    }
                    else if (status?.Status == "Your activity is ready.") // Sometimes ActivityId is null but status indicates ready (rare but possible depending on parsing)
                    {
                         Console.WriteLine("Status indicates ready, but ActivityId was not parsed.");
                         isProcessing = false;
                    }
                }
                else
                {
                    Console.WriteLine($"Failed to check status: {response.StatusCode}");
                    isProcessing = false;
                }
            }
        }
    }
}