ComponentInstaller.cs

using System.Text.Json;
using Spectre.Console;
using ShellUI.Native.Core.Models;
using ShellUI.Native.Templates;

namespace ShellUI.Native.CLI.Services;

// Handles the 'add' command - installs components to the project
public static class ComponentInstaller
{
    public static async Task InstallComponents(string[] components, bool force)
    {
        var configPath = Path.Combine(Directory.GetCurrentDirectory(), "shellui-native.json");

        if (!File.Exists(configPath))
        {
            AnsiConsole.MarkupLine("[red]ShellUI Native not initialized![/]");
            AnsiConsole.MarkupLine("[yellow]Run 'shellui-native init' first[/]");
            return;
        }

        var configJson = await File.ReadAllTextAsync(configPath);
        var config = JsonSerializer.Deserialize<ShellUINativeConfig>(configJson);

        if (config == null)
        {
            AnsiConsole.MarkupLine("[red]Failed to read shellui-native.json[/]");
            return;
        }

        var projectInfo = ProjectDetector.DetectProject();

        // Parse comma-separated components; a part installs its whole family
        var componentList = new List<string>();
        foreach (var comp in components.SelectMany(c => c.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)))
        {
            var family = ComponentRegistry.GetFamily(comp);
            if (family != null)
                AnsiConsole.MarkupLine($"[dim]'{comp}' is part of '{family}', installing '{family}'[/]");
            var name = family ?? comp;
            if (!componentList.Contains(name))
                componentList.Add(name);
        }

        var tally = new InstallTally();
        var failedComponents = new List<string>();
        var installedSet = new HashSet<string>();

        // Show dependency information
        foreach (var componentName in componentList)
        {
            var metadata = ComponentRegistry.GetMetadata(componentName);
            if (metadata != null && metadata.Dependencies.Count > 0)
            {
                AnsiConsole.MarkupLine($"[green]●[/] [bold]{componentName}[/] requires: [yellow]{string.Join(", ", metadata.Dependencies)}[/]");
            }
        }

        AnsiConsole.MarkupLine("");

        await Loaders.SnakeStatus()
            .StartAsync("Installing components...", async ctx =>
            {
                foreach (var componentName in componentList)
                {
                    ctx.Status($"Installing {componentName}...");
                    await InstallComponentWithDependenciesAsync(
                        componentName, config, projectInfo, force,
                        installedSet, tally, failedComponents);
                }
            });

        // Update config
        var updatedJson = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
        await File.WriteAllTextAsync(configPath, updatedJson);

        // Summary
        AnsiConsole.MarkupLine("");
        if (tally.Success > 0)
            AnsiConsole.MarkupLine($"[green]Installed {tally.Success} component(s) successfully![/]");
        if (tally.Skipped > 0)
            AnsiConsole.MarkupLine($"[yellow]Skipped {tally.Skipped} component(s) (already exists, use --force to overwrite)[/]");
        if (failedComponents.Count > 0)
            AnsiConsole.MarkupLine($"[red]Failed: {string.Join(", ", failedComponents)}[/]");
    }

    // " Did you mean 'x' or 'y'?" for an unknown name, or nothing when no name is close.
    internal static string DidYouMean(string name)
    {
        var suggestions = ComponentRegistry.Suggest(name);
        return suggestions.Count == 0
            ? string.Empty
            : $" [yellow]Did you mean {string.Join(" or ", suggestions.Select(s => $"'{s}'"))}?[/]";
    }

    private static async Task InstallComponentWithDependenciesAsync(
        string componentName,
        ShellUINativeConfig config,
        ProjectInfo projectInfo,
        bool force,
        HashSet<string> installedSet,
        InstallTally tally,
        List<string> failedComponents)
    {
        if (installedSet.Contains(componentName))
            return;

        if (!ComponentRegistry.Exists(componentName))
        {
            AnsiConsole.MarkupLine($"[red]Component '{componentName}' not found[/]{DidYouMean(componentName)}");
            failedComponents.Add(componentName);
            return;
        }

        var metadata = ComponentRegistry.GetMetadata(componentName);
        if (metadata == null)
        {
            AnsiConsole.MarkupLine($"[red]Failed to get metadata for '{componentName}'[/]");
            failedComponents.Add(componentName);
            return;
        }

        // Install dependencies first
        if (metadata.Dependencies.Count > 0)
        {
            AnsiConsole.MarkupLine($"[dim]Installing dependencies for [bold]{componentName}[/]: {string.Join(", ", metadata.Dependencies)}[/]");
            foreach (var dep in metadata.Dependencies)
            {
                if (!installedSet.Contains(dep))
                {
                    await InstallComponentWithDependenciesAsync(dep, config, projectInfo, force, installedSet, tally, failedComponents);
                }
            }
        }

        // Install the component
        var result = await InstallComponentInternalAsync(componentName, metadata, config, projectInfo, force);

        if (result == InstallResult.Success)
        {
            tally.Success++;
            installedSet.Add(componentName);
        }
        else if (result == InstallResult.Skipped)
        {
            tally.Skipped++;
            installedSet.Add(componentName);
        }
        else
        {
            failedComponents.Add(componentName);
        }
    }

    private static async Task<InstallResult> InstallComponentInternalAsync(
        string componentName,
        ComponentMetadata metadata,
        ShellUINativeConfig config,
        ProjectInfo projectInfo,
        bool force)
    {
        var componentPath = Path.Combine(Directory.GetCurrentDirectory(), config.ComponentsPath, metadata.FilePath);

        if (File.Exists(componentPath) && !force)
        {
            AnsiConsole.MarkupLine($"[yellow]Skipped '{componentName}' (already exists)[/]");
            return InstallResult.Skipped;
        }

        if (!ComponentRegistry.SupportsPlatform(componentName, config.TargetPlatform))
        {
            var supported = ComponentRegistry.GetSupportedPlatforms(componentName);
            var supportedList = supported.Count == 0 ? "(none)" : string.Join(", ", supported);
            AnsiConsole.MarkupLine(
                $"[red]Component '{componentName}' has no template for {config.TargetPlatform}.[/] " +
                $"[dim]Supported platforms: {supportedList}. See docs/DEVELOPMENT_PLAN.md for the roadmap.[/]");
            return InstallResult.Failed;
        }

        var content = ComponentRegistry.GetComponentContent(componentName, config.TargetPlatform);
        if (content == null)
        {
            AnsiConsole.MarkupLine($"[red]Failed to get content for '{componentName}'[/]");
            return InstallResult.Failed;
        }

        // Replace namespace placeholder
        content = TemplateText.Apply(content, projectInfo.RootNamespace, config.ComponentsPath);

        // Ensure directory exists
        var directory = Path.GetDirectoryName(componentPath);
        if (directory != null)
        {
            Directory.CreateDirectory(directory);
        }

        await File.WriteAllTextAsync(componentPath, content);

        // Update config
        var existing = config.InstalledComponents.FirstOrDefault(c => c.Name == componentName);
        if (existing != null)
        {
            existing.Version = metadata.Version;
            existing.InstalledAt = DateTime.UtcNow;
            existing.IsCustomized = false;
        }
        else
        {
            config.InstalledComponents.Add(new InstalledComponent
            {
                Name = componentName,
                Version = metadata.Version,
                Platform = config.TargetPlatform,
                InstalledAt = DateTime.UtcNow,
                IsCustomized = false
            });
        }

        AnsiConsole.MarkupLine($"[green]✓ Installed '{componentName}'[/] [dim]({metadata.FilePath})[/]");
        return InstallResult.Success;
    }

    private enum InstallResult
    {
        Success,
        Skipped,
        Failed
    }

    private sealed class InstallTally
    {
        public int Success;
        public int Skipped;
    }
}