LlamaCasty/ViewModels/MainViewModel.Sources.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Windows;
using Microsoft.Win32;
using ytLive.Helpers;
using ytLive.Models;
using ytLive.Services;
using ytLive.ViewModels;

namespace ytLive.ViewModels;

public partial class MainViewModel
{
    private void AddSource(object? parameter)
    {
        var scene = StagedScene;
        if (scene == null) return;
        PushPreviewUndo();

        var sourceType = parameter is SourceType typed
            ? typed
            : Enum.TryParse<SourceType>(parameter?.ToString(), true, out var parsed) ? parsed : SourceType.Image;
        // Privacy blur is a Live-scene tool: it exists to hide the creator's desktop, and every
        // other scene's art is authored. Rejecting here (not only in the (+) menu) keeps a stale
        // menu item or a scripted call from planting one on BRB.
        if (sourceType == SourceType.Blur && !SceneCatalog.Is(scene.Name, SceneCatalog.Live))
            return;

        var baseName = sourceType switch
        {
            SourceType.Blur => "Blur",
            SourceType.Image => "Image",
            SourceType.TextOverlay => "Text",
            SourceType.Countdown => "Countdown",
            SourceType.WebSource => "Web Resource",
            SourceType.ChatBox => "YouTube Chat",
            SourceType.AlertBox => "Stream Alerts",
            SourceType.Scoreboard => "Scoreboard",
            _ => "Layer",
        };

        // The (+) menu only adds regular layers. The Background is a locked
        // per-screen layer managed by EnsureBackground/NormalizeBackgrounds —
        // never user-created, never deleted. YouTube Chat and Stream Alerts
        // are one-per-layout.
        if (sourceType is SourceType.DisplayCapture or SourceType.WindowCapture or SourceType.Background)
            return;
        if ((sourceType == SourceType.ChatBox && !CanAddYouTubeChat)
            || (sourceType == SourceType.AlertBox && !CanAddAlerts))
            return;

        // Web resources use "Web Resource-N" naming (0-indexed per scene)
        var webCount = scene.Elements.OfType<Source>().Count(s => s.Type == SourceType.WebSource);
        var source = new Source
        {
            Name = sourceType == SourceType.WebSource
                ? $"{baseName}-{webCount}"
                : NextSourceName(scene, baseName),
            Type = sourceType,
            X = sourceType == SourceType.ChatBox ? 1400
                : sourceType == SourceType.AlertBox ? 620
                : sourceType == SourceType.Blur ? 700 : 0,
            // The scoreboard is a full-width bar: its Y comes from the edge it owns (resolved
            // against the social bar at render time), never from a drag.
            Y = sourceType == SourceType.Scoreboard ? 1024
                : sourceType == SourceType.ChatBox ? 20
                : sourceType == SourceType.AlertBox ? 430
                : sourceType == SourceType.Blur ? 600 : 0,
            Width = sourceType == SourceType.WebSource ? 640
                : sourceType == SourceType.ChatBox ? 500
                : sourceType == SourceType.AlertBox ? 680
                : sourceType == SourceType.Scoreboard ? 1920
                : sourceType == SourceType.Blur ? 240 : 0,
            Height = sourceType == SourceType.WebSource ? 480
                : sourceType == SourceType.ChatBox ? 648
                : sourceType == SourceType.AlertBox ? 200
                : sourceType == SourceType.Scoreboard ? 56
                : sourceType == SourceType.Blur ? 160 : 0,
        };

        if (sourceType == SourceType.Blur)
        {
            // ⛔ Z-order is policy, not preference: the blur sits directly above the background and
            // BELOW the brand logo, which can never be obscured (creator ruling 2026-11-01).
            _sceneGraph.AddElement(scene, source);
            var blurIndex = scene.Elements.IndexOf(source);
            if (blurIndex >= 0) scene.Elements.Move(blurIndex, BlurInsertIndex(scene));
        }
        else
        {
            _sceneGraph.AddElement(scene, source);
        }

        if (sourceType == SourceType.WebSource)
        {
            _webView2Manager?.Register(source);
            source.PropertyChanged += (_, e) =>
            {
                if (e.PropertyName == nameof(Source.WebUri))
                    _webView2Manager?.OnWebUriChanged(source);
            };
        }

        if (sourceType == SourceType.ChatBox)
        {
            source.PropertyChanged += (_, e) =>
            {
                if (e.PropertyName is nameof(Source.ChatFontSize) or nameof(Source.ChatFontColor)
                    or nameof(Source.ChatBackgroundColor) or nameof(Source.ChatBackgroundOpacity)
                    or nameof(Source.ChatMaxMessages) or nameof(Source.ChatShowTimestamps)
                    or nameof(Source.ChatShowBadges) or nameof(Source.ChatMemberColor)
                    or nameof(Source.ChatSuperChatColor) or nameof(Source.ChatFontFamily)
                    or nameof(Source.ChatFadeSeconds) or nameof(Source.Width) or nameof(Source.Height))
                    UpdateChatBoxPreview(source);
            };
            UpdateChatBoxPreview(source);
        }

        OnPropertyChanged(nameof(ShowEmptySceneHint));
        OnPropertyChanged(nameof(ShowSourcesEmptyHint));
        OnPropertyChanged(nameof(LayerCount));
        UpdateActiveBackground();
    }

    /// <summary>Drag-to-reorder in the layer list mutates <see cref="Scene.Elements"/>
    /// directly in code-behind, bypassing SceneGraph's mutation surface. Trap it here
    /// so the new z-order persists like any other layout change. Saves IMMEDIATELY at
    /// drop — no debounce window — because a reorder is one discrete event: the write
    /// stores BOTH the layer list (new SortOrder) and the preview layout (each layer's
    /// X/Y/W/H) in the same Source rows.</summary>
    public void OnSceneElementsReordered()
    {
        // A blur may never end up above the brand logo (creator ruling 2026-11-01). Only offending
        // blurs move — a legitimate reorder inside the layer list is left exactly as dropped.
        if (StagedScene is { } scene)
        {
            var brand = scene.Elements.OfType<Source>().FirstOrDefault(s => s.IsBrandLogo);
            if (brand != null)
            {
                foreach (var blur in scene.Elements.OfType<Source>().Where(s => s.IsBlur).ToList())
                {
                    var brandIndex = scene.Elements.IndexOf(brand);
                    var blurIndex = scene.Elements.IndexOf(blur);
                    if (blurIndex > brandIndex) scene.Elements.Move(blurIndex, brandIndex);
                }
            }
        }

        if (StagedScene != null) _sceneGraph.InvalidateBake(StagedScene);
        SaveLayoutNow();
    }

    /// <summary>The slot a privacy blur belongs in: immediately after the background, which puts it
    /// below the brand logo (the logo is inserted directly above the background too, so the blur
    /// must land before it).</summary>
    private static int BlurInsertIndex(Scene scene)
    {
        var background = scene.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground);
        if (background != null) return scene.Elements.IndexOf(background) + 1;

        var brand = scene.Elements.OfType<Source>().FirstOrDefault(s => s.IsBrandLogo);
        return brand != null ? scene.Elements.IndexOf(brand) : 0;
    }

    // Duplicate resource names get an incrementing suffix with no space: Image,
    // Image2, Image3… The next free number is derived from the names actually in
    // the scene, so deleting a middle resource never collides with a survivor.
    private static string NextSourceName(Scene scene, string baseName)
    {
        var taken = scene.Elements.OfType<Source>()
            .Select(s => s.Name)
            .Where(n => string.Equals(n, baseName, StringComparison.OrdinalIgnoreCase)
                || (n.Length > baseName.Length
                    && n.StartsWith(baseName, StringComparison.OrdinalIgnoreCase)
                    && int.TryParse(n.Substring(baseName.Length), out _)))
            .ToHashSet(StringComparer.OrdinalIgnoreCase);
        if (!taken.Contains(baseName)) return baseName;
        for (var i = 2; ; i++)
            if (!taken.Contains($"{baseName}{i}"))
                return $"{baseName}{i}";
    }

    private void AddImage()
    {
        var scene = StagedScene;
        if (scene == null) return;

        var candidates = BuildImageCandidates();
        if (candidates.Count == 0)
        {
            var bytes = PickImageBytes("Choose an image");
            if (bytes != null) AddImageSource(bytes);
            return;
        }

        var dialog = new ReuseImageDialog(new ReuseImageViewModel(candidates))
        {
            Owner = Application.Current.MainWindow
        };
        if (dialog.ShowDialog() != true) return;

        if (dialog.WantsNew)
        {
            var bytes = PickImageBytes("Choose an image");
            if (bytes != null) AddImageSource(bytes);
        }
        else
        {
            AddReusedImage(dialog.PickedAssetId!);
        }
    }

    private List<ReuseImageCandidate> BuildImageCandidates()
    {
        var candidates = new List<ReuseImageCandidate>();
        foreach (var scene in Scenes)
        foreach (var source in scene.Elements.OfType<Source>().Where(s => s.Type == SourceType.Image && !string.IsNullOrWhiteSpace(s.AssetId)))
        {
            candidates.Add(new ReuseImageCandidate
            {
                SceneName = scene.Name,
                SourceName = source.Name,
                AssetId = source.AssetId!
            });
        }
        return candidates;
    }

    private byte[]? PickImageBytes(string title)
    {
        var dialog = new OpenFileDialog
        {
            Title = title,
            Filter = "Image files (*.png;*.jpg;*.jpeg;*.bmp;*.gif;*.webp)|*.png;*.jpg;*.jpeg;*.bmp;*.gif;*.webp|All files (*.*)|*.*"
        };
        if (dialog.ShowDialog() != true) return null;
        try
        {
            return File.ReadAllBytes(dialog.FileName);
        }
        catch (Exception ex)
        {
            _notifications.Warning("Couldn't read that image", ex.Message);
            return null;
        }
    }

    private string? AddAsset(byte[] bytes)
    {
        try
        {
            var image = ImageCache.FromBytes(bytes);
            var id = _layoutStore.UpsertAsset(bytes, image?.PixelWidth ?? 0, image?.PixelHeight ?? 0);
            if (id != null && image != null) ImageCache.Put(id, image);
            return id;
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Asset store failed: {ex.Message}");
            return null;
        }
    }

    private void AddImageSource(byte[] bytes)
    {
        if (bytes.Length == 0) return;
        var assetId = AddAsset(bytes);
        if (assetId != null) AddReusedImage(assetId);
    }

    private void AddReusedImage(string assetId)
    {
        var scene = StagedScene;
        if (scene == null || string.IsNullOrWhiteSpace(assetId)) return;

        var source = new Source { Name = NextSourceName(scene, "Image"), Type = SourceType.Image, AssetId = assetId };

        var image = ImageCache.Get(assetId);
        if (image != null)
        {
            var scale = Math.Min(640.0 / image.PixelWidth, 480.0 / image.PixelHeight);
            source.Width = image.PixelWidth * scale;
            source.Height = image.PixelHeight * scale;
            source.X = (1920 - source.Width) / 2;
            source.Y = (1080 - source.Height) / 2;
        }

        _sceneGraph.AddElement(scene, source);
        SelectedElement = source;
        OnPropertyChanged(nameof(ShowEmptySceneHint));
        OnPropertyChanged(nameof(ShowSourcesEmptyHint));
        OnPropertyChanged(nameof(LayerCount));
        UpdateActiveBackground();
    }

    // Removes an element from the active scene. For a webcam config this drops the
    // scene's usage and releases one camera reference (CameraManager stops the
    // session when the last using scene lets go). The webcam identity survives —
    // it's the app-level default, so removing a scene's placement re-enables Add
    // for the same camera instead of dropping it.
    internal void RemoveElement(SceneElement? element)
    {
        var scene = StagedScene;
        if (scene == null || element == null) return;
        if (element is Source { IsBackground: true } or Source { IsBrandLogo: true }) return;
        if (element is WebcamSceneConfig && _webcam != null)
        {
            if (SelectedElement == element)
                SelectedElement = null;
            _ = _cameraManager.ReleaseAsync(_webcam.DeviceId);
        }
        if (element is Source { Type: SourceType.WebSource } webSource)
            _webView2Manager?.Unregister(webSource.Id);
        _sceneGraph.RemoveElement(scene, element);

        if (element is WebcamSceneConfig)
        {
            SyncWebcamEffects(); // drop a variant nobody shows any more
            OnPropertyChanged(nameof(CanAddWebcam));
            OnPropertyChanged(nameof(CanShowWebcamInStagedScene));
            OnPropertyChanged(nameof(WebcamAddToolTip));
        }

        OnPropertyChanged(nameof(ShowEmptySceneHint));
        OnPropertyChanged(nameof(ShowSourcesEmptyHint));
        OnPropertyChanged(nameof(LayerCount));
        UpdateActiveBackground();
    }
}