DirectEditingTests.cs

using System;
using System.Linq;
using PdfEditorApp.Core.Models;
using PdfEditorApp.Core.Models.Elements;
using PdfEditorApp.Models;
using PdfEditorApp.Services;
using PdfEditorApp.ViewModels;
using PdfEditorApp.ViewModels.ElementViewModels;
using Xunit;

namespace PdfEditorApp.Tests;

public class DirectEditingTests
{
    [Fact]
    public void TextElement_EditMode_TransitionsCorrectly()
    {
        var textEl = new TextElementViewModel
        {
            Text = "Original Content",
            FontSize = 14,
            IsInEditMode = false
        };

        Assert.False(textEl.IsInEditMode);

        // Enter edit mode
        textEl.IsInEditMode = true;
        Assert.True(textEl.IsInEditMode);

        // Edit text
        textEl.Text = "Updated Direct Canvas Text";
        Assert.Equal("Updated Direct Canvas Text", textEl.Text);

        // Exit edit mode
        textEl.IsInEditMode = false;
        Assert.False(textEl.IsInEditMode);
    }

    [Fact]
    public void InspectorViewModel_FontSize_IncreaseAndDecreaseCommands()
    {
        var inspector = new InspectorViewModel();
        var page = new PageViewModel();
        var textEl = new TextElementViewModel
        {
            Text = "Headline Text",
            FontSize = 16
        };
        page.AddElement(textEl);
        inspector.UpdateSelection(textEl, page);

        Assert.True(inspector.IsTextElement);
        Assert.Equal(16, textEl.FontSize);

        // Increase font size
        inspector.IncreaseFontSizeCommand.Execute(null);
        Assert.Equal(17, textEl.FontSize);

        // Increase again
        inspector.IncreaseFontSizeCommand.Execute(null);
        Assert.Equal(18, textEl.FontSize);

        // Decrease font size
        inspector.DecreaseFontSizeCommand.Execute(null);
        Assert.Equal(17, textEl.FontSize);

        // Test bounds and finish edit mode
        textEl.IsInEditMode = false;
        Assert.False(textEl.IsInEditMode);

        inspector.StartEditModeCommand.Execute(null);
        Assert.True(textEl.IsInEditMode);

        inspector.ToggleEditModeCommand.Execute(null);
        Assert.False(textEl.IsInEditMode);

        inspector.ToggleEditModeCommand.Execute(null);
        Assert.True(textEl.IsInEditMode);

        inspector.FinishEditModeCommand.Execute(null);
        Assert.False(textEl.IsInEditMode);
    }

    [Fact]
    public void InspectorViewModel_TextFormattingCommands_WorkDirectly()
    {
        var inspector = new InspectorViewModel();
        var page = new PageViewModel();
        var textEl = new TextElementViewModel
        {
            Text = "Sample Paragraph",
            FontSize = 12,
            IsBold = false,
            IsItalic = false,
            IsUnderline = false,
            Alignment = TextAlignmentMode.Left
        };
        page.AddElement(textEl);
        inspector.UpdateSelection(textEl, page);

        // Toggle Bold
        inspector.ToggleBoldCommand.Execute(null);
        Assert.True(textEl.IsBold);

        // Toggle Italic
        inspector.ToggleItalicCommand.Execute(null);
        Assert.True(textEl.IsItalic);

        // Toggle Underline
        inspector.ToggleUnderlineCommand.Execute(null);
        Assert.True(textEl.IsUnderline);

        // Change Alignment
        inspector.SetAlignmentCommand.Execute("Center");
        Assert.Equal(TextAlignmentMode.Center, textEl.Alignment);

        // Change Color
        inspector.SetTextColorCommand.Execute("#0F6CBD");
        Assert.Equal("#0F6CBD", textEl.TextColorHex);

        // Auto-Fit Text
        inspector.AutoFitTextBothCommand.Execute(null);
        Assert.True(textEl.Width > 0);
        Assert.True(textEl.Height > 0);
    }

    [Fact]
    public void ShapeElement_InPlaceLabelEditing_WorksCorrectly()
    {
        var shape = new ShapeElementViewModel
        {
            ShapeType = ShapeType.RoundedRectangle,
            Label = "CONFIDENTIAL",
            LabelFontSize = 14,
            IsInEditMode = false
        };

        Assert.False(shape.IsInEditMode);
        Assert.Equal("CONFIDENTIAL", shape.Label);

        // Enter label edit mode
        shape.IsInEditMode = true;
        Assert.True(shape.IsInEditMode);

        // Edit label directly
        shape.Label = "APPROVED";
        Assert.Equal("APPROVED", shape.Label);

        // Exit edit mode
        shape.IsInEditMode = false;
        Assert.False(shape.IsInEditMode);
    }

    [Fact]
    public void TableElement_DirectCellAndHeaderEditing_RoundTripsModel()
    {
        var table = new TableElementViewModel();
        Assert.Equal(4, table.Headers.Count);
        Assert.Equal(3, table.Rows.Count);

        // Direct edit header
        table.Headers[0].Text = "Service Description";
        Assert.Equal("Service Description", table.Headers[0].Text);

        // Direct edit cell
        table.Rows[0].Cells[0].Text = "Enterprise Architecture Consulting";
        table.Rows[0].Cells[3].Text = "$12,500.00";

        Assert.Equal("Enterprise Architecture Consulting", table.Rows[0].Cells[0].Text);
        Assert.Equal("$12,500.00", table.Rows[0].Cells[3].Text);

        // Convert to Model and back
        var model = (PdfTableElement)table.ToModel();
        Assert.Equal("Service Description", model.Headers[0]);
        Assert.Equal("Enterprise Architecture Consulting", model.Rows[0][0]);
        Assert.Equal("$12,500.00", model.Rows[0][3]);

        var restoredTable = new TableElementViewModel();
        restoredTable.LoadFromModel(model);

        Assert.Equal("Service Description", restoredTable.Headers[0].Text);
        Assert.Equal("Enterprise Architecture Consulting", restoredTable.Rows[0].Cells[0].Text);
        Assert.Equal("$12,500.00", restoredTable.Rows[0].Cells[3].Text);
    }

    [Fact]
    public void StickyNoteElement_DirectTextEditing_WorksCorrectly()
    {
        var note = new StickyNoteElementViewModel
        {
            Author = "Reviewer",
            NoteText = "Please update section 3"
        };

        note.NoteText = "Section 3 approved with revisions.";
        var model = (PdfStickyNoteElement)note.ToModel();
        Assert.Equal("Section 3 approved with revisions.", model.NoteText);
    }

    [Fact]
    public void PageViewModel_SelectionChange_DeactivatesEditModeOnOtherElements()
    {
        var page = new PageViewModel();
        var el1 = new TextElementViewModel { Text = "Element 1", IsInEditMode = true };
        var el2 = new TextElementViewModel { Text = "Element 2", IsInEditMode = false };
        page.AddElement(el1);
        page.AddElement(el2);

        page.SelectElement(el1);
        el1.IsInEditMode = true;
        Assert.True(el1.IsSelected);
        Assert.True(el1.IsInEditMode);

        // Selecting el2 must automatically deactivate edit mode on el1
        page.SelectElement(el2);
        Assert.False(el1.IsSelected);
        Assert.False(el1.IsInEditMode);
        Assert.True(el2.IsSelected);

        // Clearing selection must deactivate edit mode on all elements
        el2.IsInEditMode = true;
        Assert.True(el2.IsInEditMode);
        page.ClearSelection();
        Assert.False(el2.IsSelected);
        Assert.False(el2.IsInEditMode);
    }

    [Fact]
    public void DeleteSelectedElement_SingleElement_DeletesAndSupportsUndo()
    {
        var undoRedo = new UndoRedoService();
        var inspector = new InspectorViewModel { UndoRedo = undoRedo };
        var page = new PageViewModel();
        var textEl = new TextElementViewModel { Text = "Heading to delete" };
        page.AddElement(textEl);
        page.SelectElement(textEl);
        inspector.UpdateSelection(textEl, page);

        Assert.Single(page.Elements);
        Assert.Equal(textEl, page.SelectedElement);

        // Execute Delete
        inspector.DeleteSelectedElementCommand.Execute(null);

        Assert.Empty(page.Elements);
        Assert.Null(page.SelectedElement);
        Assert.Empty(page.SelectedElements);
        Assert.True(undoRedo.CanUndo);

        // Undo Delete
        undoRedo.Undo();
        Assert.Single(page.Elements);
        Assert.Equal("Heading to delete", ((TextElementViewModel)page.Elements[0]).Text);
    }

    [Fact]
    public void DeleteSelectedElement_MultiElement_DeletesAllAndSupportsUndo()
    {
        var undoRedo = new UndoRedoService();
        var inspector = new InspectorViewModel { UndoRedo = undoRedo };
        var page = new PageViewModel();
        var el1 = new TextElementViewModel { Text = "Heading 1" };
        var el2 = new TextElementViewModel { Text = "Paragraph 1" };
        var el3 = new ShapeElementViewModel { Width = 100, Height = 50 };
        page.AddElement(el1);
        page.AddElement(el2);
        page.AddElement(el3);

        page.SelectElements(new[] { el1, el2 });
        inspector.UpdateSelection(el2, page);

        Assert.Equal(3, page.Elements.Count);
        Assert.Equal(2, page.SelectedElements.Count);

        // Execute Delete
        inspector.DeleteSelectedElementCommand.Execute(null);

        Assert.Single(page.Elements);
        Assert.Contains(el3, page.Elements);
        Assert.Empty(page.SelectedElements);
        Assert.True(undoRedo.CanUndo);

        // Undo Delete
        undoRedo.Undo();
        Assert.Equal(3, page.Elements.Count);
        Assert.Contains(el1, page.Elements);
        Assert.Contains(el2, page.Elements);
        Assert.Contains(el3, page.Elements);
    }

    [Fact]
    public void InspectorViewModel_ToggleBold_WithTextSelection_FormatsOnlySelection_AndSupportsUndo()
    {
        var undoRedo = new UndoRedoService();
        var inspector = new InspectorViewModel { UndoRedo = undoRedo };
        var page = new PageViewModel();
        var textEl = new TextElementViewModel
        {
            Text = "normative period of rec\nmacro environment,\nd top-line revenue"
        };
        page.AddElement(textEl);
        inspector.UpdateSelection(textEl, page);

        // Enter edit mode and select "macro environment,"
        textEl.IsInEditMode = true;
        textEl.UpdateTextSelection(24, 18, "macro environment,");
        Assert.True(textEl.HasTextSelection);

        // Execute ToggleBold
        inspector.ToggleBoldCommand.Execute(null);

        Assert.Equal("normative period of rec\n**macro environment,**\nd top-line revenue", textEl.Text);
        Assert.False(textEl.IsBold); // Element-wide property remains false!
        Assert.NotNull(textEl.Spans); // Spans are generated
        Assert.True(undoRedo.CanUndo);

        // Undo
        undoRedo.Undo();
        Assert.Equal("normative period of rec\nmacro environment,\nd top-line revenue", textEl.Text);

        // Redo
        undoRedo.Redo();
        Assert.Equal("normative period of rec\n**macro environment,**\nd top-line revenue", textEl.Text);
    }

    [Fact]
    public void InspectorViewModel_ToggleBold_WithoutTextSelection_TogglesElementProperty()
    {
        var undoRedo = new UndoRedoService();
        var inspector = new InspectorViewModel { UndoRedo = undoRedo };
        var page = new PageViewModel();
        var textEl = new TextElementViewModel { Text = "Sample Heading", IsBold = false };
        page.AddElement(textEl);
        inspector.UpdateSelection(textEl, page);

        Assert.False(textEl.IsBold);
        Assert.False(textEl.HasTextSelection);

        // Execute ToggleBold
        inspector.ToggleBoldCommand.Execute(null);
        Assert.True(textEl.IsBold);

        // Toggle again
        inspector.ToggleBoldCommand.Execute(null);
        Assert.False(textEl.IsBold);
    }

    [Fact]
    public void InspectorViewModel_SetTextColor_WithTextSelection_FormatsOnlySelection()
    {
        var undoRedo = new UndoRedoService();
        var inspector = new InspectorViewModel { UndoRedo = undoRedo };
        var page = new PageViewModel();
        var textEl = new TextElementViewModel { Text = "Hello World" };
        page.AddElement(textEl);
        inspector.UpdateSelection(textEl, page);

        textEl.IsInEditMode = true;
        textEl.UpdateTextSelection(6, 5, "World");

        inspector.SetTextColorCommand.Execute("#0F6CBD");

        Assert.Equal("Hello <color=#0F6CBD>World</color>", textEl.Text);
        Assert.NotNull(textEl.Spans);
        var coloredSpan = textEl.Spans.FirstOrDefault(s => s.TextColorHex == "#0F6CBD");
        Assert.NotNull(coloredSpan);
        Assert.Equal("World", coloredSpan.Text);
    }
}