builder.Services.AddHealth();

public class HealthExampleService
{
    private readonly IHealthService _healthService;

    public HealthExampleService(IHealthService healthService)
    {
        _healthService = healthService;
    }

    public async Task<List<StepsDto>> GetTodaysStepsAsync()
    {
        if (!_healthService.IsSupported)
        {
            return [];
        }

        var timeRange = HealthTimeRange.FromDateTime(DateTime.Today, DateTime.Now);

        return await _healthService.GetHealthData<StepsDto>(timeRange);
    }
}

public async Task AnalyzeStepsData()
{
    var timeRange = HealthTimeRange.FromDateTime(DateTime.Today, DateTime.Now);
    var steps = await _healthService.GetHealthData<StepsDto>(timeRange);
    
    foreach (var stepRecord in steps)
    {
        // Common properties from BaseHealthMetricDto
        Console.WriteLine($"ID: {stepRecord.Id}");
        Console.WriteLine($"Source: {stepRecord.DataOrigin}");
        Console.WriteLine($"Recorded: {stepRecord.Timestamp}");
        
        // Steps-specific data
        Console.WriteLine($"Steps: {stepRecord.Count}");
        
        // Time range data (IHealthTimeRange)
        Console.WriteLine($"Period: {stepRecord.StartTime} to {stepRecord.EndTime}");
        Console.WriteLine($"Duration: {stepRecord.Duration}");
        
        // Type-safe duration checking
        if (stepRecord is IHealthTimeRange timeRange)
        {
            Console.WriteLine($"This measurement lasted {timeRange.Duration.TotalMinutes} minutes");
        }
    }
}

public async Task<StepsDto?> GetSpecificRecord(string recordId)
{
    return await _healthService.GetHealthRecord<StepsDto>(recordId);
}

public async Task DeleteRecord(string recordId)
{
    var isDeleted = await _healthService.DeleteHealthData<StepsDto>(recordId);

    if (isDeleted)
    {
        Console.WriteLine("Record deleted successfully");
    }
}

public async Task ShowTodaysSummary()
{
    var todayRange = HealthTimeRange.FromDateTime(DateTime.Today, DateTime.Now);

    // Cumulative types (steps, calories) return a sum
    var steps = await _healthService.GetAggregatedHealthData<StepsDto>(todayRange);
    if (steps is not null)
    {
        Console.WriteLine($"Total steps today: {steps.Value}");
    }

    // Discrete types (weight, heart rate) return an average
    var weight = await _healthService.GetAggregatedHealthData<WeightDto>(todayRange);
    if (weight is not null)
    {
        Console.WriteLine($"Average weight: {weight.Value} {weight.Unit}");
    }
}

public async Task ShowWeeklySteps()
{
    var weekRange = HealthTimeRange.FromDateTime(
        DateTime.Today.AddDays(-6), DateTime.Now);

    var dailySteps = await _healthService.GetAggregatedHealthDataByInterval<StepsDto>(
        weekRange, TimeSpan.FromDays(1));

    foreach (var bucket in dailySteps)
    {
        Console.WriteLine($"{bucket.StartTime:ddd MMM dd}: {bucket.Value:N0} steps");
    }
}

public class HealthSyncService
{
    private readonly IHealthService _healthService;
    private string? _syncToken;

    // Call once to establish a baseline - captures the current state
    public async Task InitializeSync()
    {
        var dataTypes = new List<HealthDataType>
        {
            HealthDataType.Steps,
            HealthDataType.Weight,
            HealthDataType.ActiveCaloriesBurned
        };

        _syncToken = await _healthService.GetChangesToken(dataTypes);
        // Store _syncToken persistently (e.g., Preferences, database)
    }

    // Call periodically to get new changes since last sync
    public async Task SyncChanges()
    {
        if (_syncToken is null) return;

        var result = await _healthService.GetChanges(_syncToken);
        if (result is null) return;

        foreach (var change in result.Changes)
        {
            Console.WriteLine($"{change.Type}: {change.RecordId}");
        }

        // Update token for next call
        _syncToken = result.NextToken;

        // If more changes available, keep fetching
        if (result.HasMore)
        {
            await SyncChanges();
        }
    }
}

public async Task RequestPermissions()
{
    var permissions = new List<HealthPermissionDto>
    {
        new() { HealthDataType = HealthDataType.Steps, PermissionType = PermissionType.Read },
        new() { HealthDataType = HealthDataType.Weight, PermissionType = PermissionType.Read },
        new() { HealthDataType = HealthDataType.Height, PermissionType = PermissionType.Read }
    };

    var result = await _healthService.RequestPermissions(permissions);

    if (result.IsSuccess)
    {
        Console.WriteLine("Permissions granted!");
    }
    else
    {
        Console.WriteLine($"Permission error: {result.Error}");
    }
}

public async Task RequestPermissionsWithUpdateHandling()
{
    var permissions = new List<HealthPermissionDto>
    {
        new() { HealthDataType = HealthDataType.Steps, PermissionType = PermissionType.Read }
    };

    var result = await _healthService.RequestPermissions(permissions);

    if (result.Error == RequestPermissionError.SdkUnavailableProviderUpdateRequired)
    {
        // Show your custom UI explaining the update requirement
        bool userConfirmed = await DisplayAlert(
            "Update Required",
            "Health Connect needs to be updated to use health features.",
            "Update", "Cancel");

        if (userConfirmed)
        {
            _healthService.OpenStorePageOfHealthProvider(); // Opens Play Store
        }
    }
}

public async Task<List<WorkoutDto>> GetTodaysWorkouts()
{
    var timeRange = HealthTimeRange.FromDateTime(DateTime.Today, DateTime.Now);
    var workouts = await _healthService.Activity.Read(timeRange);

    foreach (var workout in workouts)
    {
        Console.WriteLine($"{workout.ActivityType}: {workout.StartTime:HH:mm} - {workout.EndTime:HH:mm}");
        Console.WriteLine($"Duration: {workout.DurationSeconds / 60} minutes");
        Console.WriteLine($"Source: {workout.DataOrigin}");

        if (workout.EnergyBurned.HasValue)
            Console.WriteLine($"Calories: {workout.EnergyBurned:F0} kcal");
        if (workout.AverageHeartRate.HasValue)
            Console.WriteLine($"Avg HR: {workout.AverageHeartRate:F0} BPM");
    }

    return workouts;
}

public async Task WriteCompletedWorkout()
{
    var workout = new WorkoutDto
    {
        Id = Guid.NewGuid().ToString(),
        DataOrigin = "MyApp", -> Your APP data source.
        ActivityType = ActivityType.Running,
        Title = "Morning Run",
        StartTime = DateTimeOffset.Now.AddMinutes(-30),
        EndTime = DateTimeOffset.Now,
        EnergyBurned = 250,
        Distance = 5000 // meters
    };

    await _healthService.Activity.Write(workout);
}

public class WorkoutTracker
{
    private readonly IHealthService _healthService;

    // Start a new workout session
    public async Task StartWorkout()
    {
        await _healthService.Activity.Start(
            ActivityType.Running,
            title: "Morning Run",
            dataOrigin: "MyApp"
        );
    }

    // Pause the active session
    public async Task PauseWorkout()
    {
        await _healthService.Activity.Pause();
    }

    // Resume from pause
    public async Task ResumeWorkout()
    {
        await _healthService.Activity.Resume();
    }

    // End session and save to health store
    public async Task<WorkoutDto?> EndWorkout()
    {
        // Returns the completed workout saved to Health Connect/HealthKit
        return await _healthService.Activity.End();
    }

    // Check session status
    public async Task<bool> IsWorkoutRunning() => await _healthService.Activity.IsRunning();
    public async Task<bool> IsWorkoutPaused() => await _healthService.Activity.IsPaused();
}

public async Task DetectDuplicateWorkouts()
{
    var timeRange = HealthTimeRange.FromDateTime(DateTime.Today, DateTime.Now);
    var workouts = await _healthService.Activity.Read(timeRange);

    // Find duplicates with 5-minute threshold
    var duplicates = _healthService.Activity.FindDuplicates(
        workouts,
        appSource: "MyApp",      // Your app's DataOrigin
        timeThresholdMinutes: 5  // Max time difference to consider as duplicate
    );

    foreach (var group in duplicates)
    {
        // Get the workout from your app
        var appWorkout = group.AppWorkout;

        // Get the workout from watch/other source
        var externalWorkout = group.ExternalWorkout;

        Console.WriteLine($"Duplicate found:");
        Console.WriteLine($"  App: {appWorkout?.DataOrigin} at {appWorkout?.StartTime:HH:mm}");
        Console.WriteLine($"  External: {externalWorkout?.DataOrigin} at {externalWorkout?.StartTime:HH:mm}");
        Console.WriteLine($"  Time diff: {group.StartTimeDifferenceMinutes:F1} minutes");

        // User can decide which to keep - typically keep the watch data
        // as it has more accurate heart rate and calorie data
        if (appWorkout != null)
        {
            await _healthService.Activity.Delete(appWorkout);
        }
    }
}