var detector = serviceProvider.GetRequiredService<IConflictDetector>();
var resolver = serviceProvider.GetRequiredService<IConflictResolver>();
var priorityService = serviceProvider.GetRequiredService<IModPriorityService>();

var weatherRain = new ModSource
{
    ModId = "Weather_Rain",
    ModName = "Rain",
    Category = "Weather",
    Priority = 10,     // Lower = higher precedence
    AppliedAt = DateTime.UtcNow,
    AffectedFiles = new List<string>
    {
        "particles/weather/rain.vpcf_c",
        "materials/environment/weather_overlay.vmat_c"
    }
};

var weatherSnow = new ModSource
{
    ModId = "Weather_Snow",
    ModName = "Snow",
    Category = "Weather",
    Priority = 20,     // Lower priority than Rain
    AppliedAt = DateTime.UtcNow.AddMinutes(-5),
    AffectedFiles = new List<string>
    {
        "particles/weather/rain.vpcf_c",     // ← Overlaps with Rain!
        "particles/weather/snow_particles.vpcf_c"
    }
};

// Shorthand factory:
var hudMod = ModSource.FromSelection("HUD", "Immortal Gardens");

var mods = new[] { weatherRain, weatherSnow, hudMod };
IReadOnlyList<ModConflict> conflicts = await detector.DetectConflictsAsync(mods, dotaPath, ct);

Console.WriteLine($"Found {conflicts.Count} conflict(s)");

foreach (var conflict in conflicts)
{
    Console.WriteLine($"  [{conflict.Severity}] {conflict.Type}: {conflict.Description}");
    Console.WriteLine($"  Affected files: {string.Join(", ", conflict.AffectedFiles)}");
    Console.WriteLine($"  Between: {string.Join(" vs ", conflict.ConflictingSources.Select(s => s.ModName))}");
    Console.WriteLine($"  Needs user input: {conflict.RequiresUserIntervention}");
}

var critical = detector.GetConflictsBySeverity(conflicts, ConflictSeverity.Critical);
bool hasCritical = detector.HasCriticalConflicts(conflicts);
bool needsInput = detector.RequiresUserIntervention(conflicts);

ModConflict? conflict = await detector.CheckSingleConflictAsync(weatherRain, weatherSnow, ct);
if (conflict != null)
    Console.WriteLine($"Conflict: {conflict.Description}");

// Set individual mod priority
await priorityService.SetModPriorityAsync(
    modId: "Weather_Rain",
    modName: "Rain",
    category: "Weather",
    priority: 10,          // Wins over Snow (priority 20)
    dotaPath, ct);

await priorityService.SetModPriorityAsync("Weather_Snow", "Snow", "Weather", 20, dotaPath, ct);

// Read priority
int rainPriority = await priorityService.GetModPriorityAsync("Weather_Rain", dotaPath, ct);

// Get all priorities ordered (lowest first = highest precedence)
var ordered = await priorityService.GetOrderedPrioritiesAsync(dotaPath, category: "Weather", ct);
foreach (var p in ordered)
    Console.WriteLine($"  {p.ModName}: Priority {p.Priority}");

// Sorts by priority and assigns Priority values from config
IReadOnlyList<ModSource> sorted = await priorityService.ApplyPrioritiesAsync(mods, dotaPath, ct);
// sorted[0] is the highest-priority mod

var config = await priorityService.LoadConfigAsync(dotaPath, ct);

IReadOnlyList<ConflictResolutionResult> results = await resolver.ResolveAllAsync(conflicts, config, ct);

foreach (var result in results)
{
    if (result.Success)
        Console.WriteLine($"  ✅ {result.ConflictId}: {result.WinningSource?.ModName} wins ({result.UsedStrategy})");
    else
        Console.WriteLine($"  ❌ {result.ConflictId}: {result.ErrorMessage}");
}

// Use higher priority mod
var result = await resolver.ResolveAsync(conflict, ResolutionStrategy.HigherPriority, ct);

// Use most recently applied mod
var result2 = await resolver.ResolveAsync(conflict, ResolutionStrategy.MostRecent, ct);

// Keep existing mod (discard new)
var result3 = await resolver.ResolveAsync(conflict, ResolutionStrategy.KeepExisting, ct);

// Use new mod (discard existing)
var result4 = await resolver.ResolveAsync(conflict, ResolutionStrategy.UseNew, ct);

// Attempt merge (Script/Config conflicts only, falls back to HigherPriority)
var result5 = await resolver.TryMergeAsync(conflict, ct);

// Present options to user
foreach (var option in conflict.AvailableResolutions)
    Console.WriteLine($"  [{option.Id}] {option.Strategy}: {option.Description}");

// User picks an option
var chosen = conflict.AvailableResolutions[0];  // e.g., "Use mod with higher priority"
var result = await resolver.ApplyUserChoiceAsync(conflict, chosen, ct);

bool canAuto = resolver.CanAutoResolve(conflict, config);
// true for Low/Medium severity (if AutoResolveNonBreaking = true)
// false for Critical severity (always requires user)

var config = await priorityService.LoadConfigAsync(dotaPath, ct);

// Set global default
config.DefaultStrategy = ResolutionStrategy.HigherPriority;

// Enable auto-resolve for Low+Medium severity
config.AutoResolveNonBreaking = true;

// Set per-category strategies
config.CategoryStrategies["Weather"] = ResolutionStrategy.MostRecent;
config.CategoryStrategies["HUD"] = ResolutionStrategy.HigherPriority;
config.CategoryStrategies["River"] = ResolutionStrategy.MostRecent;

// Save to disk
await priorityService.SaveConfigAsync(config, dotaPath, ct);

{
   "lastModified": "2026-02-14T12:00:00Z",
   "priorities": [
      {
         "modId": "Weather_Rain",
         "modName": "Rain",
         "category": "Weather",
         "priority": 10,
         "isLocked": false
      },
      {
         "modId": "Weather_Snow",
         "modName": "Snow",
         "category": "Weather",
         "priority": 20,
         "isLocked": false
      }
   ],
   "defaultStrategy": 0,
   "autoResolveNonBreaking": true,
   "categoryStrategies": { "Weather": 2, "River": 2 }
}