RackPeek/Shared.Rcl/Laptops/LaptopCardComponent.razor

@using RackPeek.Domain.Resources.Laptops
@using RackPeek.Domain.Resources.SubResources
@using RackPeek.Domain.UseCases.Cpus
@using RackPeek.Domain.UseCases.Drives
@using RackPeek.Domain.UseCases.Gpus
@inject IGetResourceByNameUseCase<Laptop> GetByNameUseCase
@inject UpdateLaptopUseCase UpdateUseCase
@inject IDeleteResourceUseCase<Laptop> DeleteUseCase
@inject IAddCpuUseCase<Laptop> AddCpuUseCase
@inject IUpdateCpuUseCase<Laptop> UpdateCpuUseCase
@inject IRemoveCpuUseCase<Laptop> RemoveCpuUseCase
@inject IAddDriveUseCase<Laptop> AddDriveUseCase
@inject IUpdateDriveUseCase<Laptop> UpdateDriveUseCase
@inject IRemoveDriveUseCase<Laptop> RemoveDriveUseCase
@inject IAddGpuUseCase<Laptop> AddGpuUseCase
@inject IUpdateGpuUseCase<Laptop> UpdateGpuUseCase
@inject IRemoveGpuUseCase<Laptop> RemoveGpuUseCase
@inject ICloneResourceUseCase<Laptop> CloneUseCase
@inject IRenameResourceUseCase<Laptop> RenameUseCase
@inject NavigationManager Nav

<div class="border border-zinc-800 rounded p-4 bg-zinc-900"
     data-testid=@($"laptop-item-{Laptop.Name.Replace(" ", "-")}")>

    <div class="flex justify-between items-center mb-3">

        <div class="text-zinc-100 hover:text-emerald-300">
            <NavLink href="@($"resources/hardware/{Uri.EscapeDataString(Laptop.Name)}")"
                     class="block"
                     data-testid=@($"laptop-item-{Laptop.Name.Replace(" ", "-")}-link")>
                @Laptop.Name
            </NavLink>
        </div>

        <div class="flex items-center gap-2">

            @if (!string.IsNullOrWhiteSpace(Laptop.Model))
            {
                <span class="text-xs text-zinc-400"
                      data-testid="laptop-model-badge">
                    @Laptop.Model
                </span>
            }

            <button data-testid="rename-laptop-button"
                    class="text-xs text-blue-400 hover:text-blue-300 transition"
                    @onclick="OpenRename">
                Rename
            </button>

            <button data-testid="clone-laptop-button"
                    class="text-xs text-emerald-400 hover:text-emerald-300 transition"
                    @onclick="OpenClone">
                Clone
            </button>

            <button data-testid="delete-laptop-button"
                    class="text-xs text-red-400 hover:text-red-300 transition"
                    @onclick="ConfirmDelete">
                Delete
            </button>

        </div>
    </div>

    <div class="grid grid-cols-1 md:grid-cols-2 gap-3 text-sm">

        <!-- CPU -->
        <div data-testid="laptop-cpu-section">
            <div class="flex items-center justify-between mb-1 group">
                <div class="text-zinc-400">
                    CPU
                    <button data-testid="add-cpu-button"
                            class="hover:text-emerald-400 transition"
                            @onclick="OpenAddCpu">
                        +
                    </button>
                </div>
            </div>

            @if (Laptop.Cpus?.Any() == true)
            {
                @foreach (var cpu in Laptop.Cpus)
                {
                    <div
                        class="flex items-center justify-between text-zinc-300 group hover:bg-zinc-800/40 rounded px-1 py-0.5">
                        <button data-testid=@($"edit-cpu-{cpu.ToString().Replace(" ", "-")}")
                                class="hover:text-emerald-400"
                                @onclick="() => OpenEditCpu(cpu)">
                            @cpu.Model — @cpu.Cores cores / @cpu.Threads threads
                        </button>
                    </div>
                }
            }
        </div>

        <!-- RAM -->
        <div data-testid="laptop-ram-section">
            <div class="text-zinc-400 mb-1">
                RAM
                <button data-testid="edit-ram-button"
                        class="hover:text-emerald-400 transition"
                        @onclick="EditRam">
                    +
                </button>
            </div>

            @if (Laptop.Ram is not null)
            {
                <div
                    class="flex items-center justify-between text-zinc-300 group hover:bg-zinc-800/40 rounded px-1 py-0.5">
                    <button data-testid="ram-value-button"
                            class="hover:text-emerald-400"
                            @onclick="EditRam">
                        @($"{Laptop.Ram.Size} GB {Laptop.Ram.Mts} MT/s")
                    </button>
                </div>
            }
        </div>

        <!-- Drives -->
        <div data-testid="laptop-drive-section">
            <div class="flex items-center justify-between mb-1 group">
                <div class="text-zinc-400">
                    Drives
                    <button data-testid="add-drive-button"
                            class="hover:text-emerald-400 transition"
                            @onclick="OpenAddDrive">
                        +
                    </button>
                </div>
            </div>

            @if (Laptop.Drives?.Any() == true)
            {
                @foreach (var drive in Laptop.Drives)
                {
                    <div
                        class="flex items-center justify-between text-zinc-300 group hover:bg-zinc-800/40 rounded px-1 py-0.5">
                        <button data-testid=@($"edit-drive-{drive.Type}-{drive.Size}")
                                class="hover:text-emerald-400"
                                @onclick="() => OpenEditDrive(drive)">
                            @drive.Type — @drive.Size GB
                        </button>
                    </div>
                }
            }
        </div>

        <!-- GPUs -->
        <div data-testid="laptop-gpu-section">
            <div class="flex items-center justify-between mb-1 group">
                <div class="text-zinc-400">
                    GPUs
                    <button data-testid="add-gpu-button"
                            class="hover:text-emerald-400 transition"
                            @onclick="OpenAddGpu">
                        +
                    </button>
                </div>
            </div>

            @if (Laptop.Gpus?.Any() == true)
            {
                @foreach (var gpu in Laptop.Gpus)
                {
                    <div
                        class="flex items-center justify-between text-zinc-300 group hover:bg-zinc-800/40 rounded px-1 py-0.5">
                        <button data-testid=@($"edit-gpu-{gpu.Model}-{gpu.Vram}")
                                class="hover:text-emerald-400"
                                @onclick="() => OpenEditGpu(gpu)">
                            @gpu.Model — @gpu.Vram GB VRAM
                        </button>
                    </div>
                }
            }
        </div>

    </div>

    <ResourceTagEditor Resource="Laptop"
                       TestIdPrefix="laptop"/>

    <ResourceLabelEditor Resource="Laptop"
                         TestIdPrefix="laptop"/>


    <div class="md:col-span-2"
         data-testid="laptop-notes-section">

        <div class="text-zinc-400 mb-1">Notes</div>

        @if (!_editingNotes)
        {
            <MarkdownViewer Value="@Laptop.Notes"
                            ShowEditButton="true"
                            OnEdit="BeginNotesEdit"
                            TestIdPrefix="laptop-notes-viewer"/>
        }
        else
        {
            <MarkdownEditor @bind-Value="_notesDraft"
                            ShowActionButtons="true"
                            OnSave="SaveNotes"
                            OnCancel="CancelNotesEdit"
                            TestIdPrefix="laptop-notes-editor"/>
        }
    </div>

</div>

<CpuModal IsOpen="@_cpuModalOpen"
          IsOpenChanged="v => _cpuModalOpen = v"
          Value="@_editingCpu"
          OnSubmit="HandleCpuSubmit"
          OnDelete="HandleCpuDelete"
          TestIdPrefix="laptop"/>


<RamModal IsOpen="@_isRamModalOpen"
          IsOpenChanged="v => _isRamModalOpen = v"
          Value="@Laptop.Ram"
          OnSubmit="HandleRamSubmit"
          TestIdPrefix="laptop"/>


<DriveModal IsOpen="@_driveModalOpen"
            IsOpenChanged="v => _driveModalOpen = v"
            Value="@_editingDrive"
            OnSubmit="HandleDriveSubmit"
            OnDelete="HandleDriveDelete"
            TestIdPrefix="laptop"/>


<GpuModal IsOpen="@_gpuModalOpen"
          IsOpenChanged="v => _gpuModalOpen = v"
          Value="@_editingGpu"
          OnSubmit="HandleGpuSubmit"
          OnDelete="HandleGpuDelete"
          TestIdPrefix="laptop"/>


<ConfirmModal IsOpen="_confirmDeleteOpen"
              IsOpenChanged="v => _confirmDeleteOpen = v"
              Title="Delete laptop"
              ConfirmText="Delete"
              ConfirmClass="bg-red-600 hover:bg-red-500"
              OnConfirm="DeleteServer"
              TestIdPrefix="Laptop">
    Are you sure you want to delete <strong>@Laptop.Name</strong>?
</ConfirmModal>

<StringValueModal IsOpen="_renameOpen"
                  IsOpenChanged="v => _renameOpen = v"
                  Title="Rename laptop"
                  Description="Enter a new name for this laptop"
                  Label="New laptop name"
                  Value="@Laptop.Name"
                  OnSubmit="HandleRenameSubmit"
                  TestIdPrefix="laptop-rename"/>

<StringValueModal IsOpen="_cloneOpen"
                  IsOpenChanged="v => _cloneOpen = v"
                  Title="Clone resource"
                  Description="Enter a name for the cloned resource"
                  Label="New resource name"
                  Value="@($"{Laptop.Name}-copy")"
                  OnSubmit="HandleCloneSubmit"
                  TestIdPrefix="laptop-clone"/>

@code {
    [Parameter] [EditorRequired] public Laptop Laptop { get; set; } = default!;

    #region RAM

    private bool _isRamModalOpen;

    private void EditRam()
    {
        _isRamModalOpen = true;
    }

    private async Task HandleRamSubmit(Ram? value)
    {
        _isRamModalOpen = false;
        await UpdateUseCase.ExecuteAsync(Laptop.Name, Laptop.Model, value?.Size ?? 0, value?.Mts ?? 0, Laptop.Notes);
        Laptop = await GetByNameUseCase.ExecuteAsync(Laptop.Name);
    }

    #endregion

    #region CPU

    bool _cpuModalOpen;
    int _editingCpuIndex;
    Cpu? _editingCpu;

    void OpenAddCpu()
    {
        _editingCpuIndex = -1;
        _editingCpu = null;
        _cpuModalOpen = true;
    }

    void OpenEditCpu(Cpu cpu)
    {
        _editingCpu = cpu;
        Laptop.Cpus ??= new List<Cpu>();
        _editingCpuIndex = Laptop.Cpus.IndexOf(cpu);
        ;
        _cpuModalOpen = true;
    }

    async Task HandleCpuSubmit(Cpu cpu)
    {
        Laptop.Cpus ??= new List<Cpu>();

        if (_editingCpuIndex < 0)
        {
            await AddCpuUseCase.ExecuteAsync(Laptop.Name, cpu.Model, cpu.Cores, cpu.Threads);
        }
        else
        {
            await UpdateCpuUseCase.ExecuteAsync(Laptop.Name, _editingCpuIndex, cpu.Model, cpu.Cores, cpu.Threads);
        }

        Laptop = await GetByNameUseCase.ExecuteAsync(Laptop.Name);
    }

    async Task HandleCpuDelete(Cpu cpu)
    {
        await RemoveCpuUseCase.ExecuteAsync(Laptop.Name, _editingCpuIndex);
        Laptop = await GetByNameUseCase.ExecuteAsync(Laptop.Name);
    }

    #endregion

    #region Drives

    bool _driveModalOpen;
    int _editingDriveIndex;
    Drive? _editingDrive;

    void OpenAddDrive()
    {
        _editingDriveIndex = -1;
        _editingDrive = null;
        _driveModalOpen = true;
    }

    void OpenEditDrive(Drive drive)
    {
        _editingDrive = drive;
        Laptop.Drives ??= new List<Drive>();
        _editingDriveIndex = Laptop.Drives.IndexOf(drive);
        ;
        _driveModalOpen = true;
    }

    async Task HandleDriveSubmit(Drive drive)
    {
        Laptop.Drives ??= new List<Drive>();

        if (_editingDriveIndex < 0)
        {
            await AddDriveUseCase.ExecuteAsync(Laptop.Name, drive.Type, drive.Size);
        }
        else
        {
            await UpdateDriveUseCase.ExecuteAsync(Laptop.Name, _editingDriveIndex, drive.Type, drive.Size);
        }

        Laptop = await GetByNameUseCase.ExecuteAsync(Laptop.Name);
        StateHasChanged();
    }

    async Task HandleDriveDelete(Drive drive)
    {
        await RemoveDriveUseCase.ExecuteAsync(Laptop.Name, _editingDriveIndex);
        Laptop = await GetByNameUseCase.ExecuteAsync(Laptop.Name);
        StateHasChanged();
    }

    #endregion

    #region GPUs

    bool _gpuModalOpen;
    int _editingGpuIndex;
    Gpu? _editingGpu;

    void OpenAddGpu()
    {
        _editingGpuIndex = -1;
        _editingGpu = null;
        _gpuModalOpen = true;
    }

    void OpenEditGpu(Gpu gpu)
    {
        Laptop.Gpus ??= new List<Gpu>();
        _editingGpuIndex = Laptop.Gpus.IndexOf(gpu);
        _editingGpu = gpu;
        _gpuModalOpen = true;
    }

    async Task HandleGpuSubmit(Gpu gpu)
    {
        Laptop.Gpus ??= new List<Gpu>();

        if (_editingGpuIndex < 0)
        {
            await AddGpuUseCase.ExecuteAsync(
                Laptop.Name,
                gpu.Model,
                gpu.Vram);
        }
        else
        {
            await UpdateGpuUseCase.ExecuteAsync(
                Laptop.Name,
                _editingGpuIndex,
                gpu.Model,
                gpu.Vram);
        }

        Laptop = await GetByNameUseCase.ExecuteAsync(Laptop.Name);
    }

    async Task HandleGpuDelete(Gpu gpu)
    {
        await RemoveGpuUseCase.ExecuteAsync(Laptop.Name, _editingGpuIndex);
        Laptop = await GetByNameUseCase.ExecuteAsync(Laptop.Name);
    }

    #endregion

}

@code {
    private bool _confirmDeleteOpen;
    [Parameter] public EventCallback<string> OnDeleted { get; set; }

    void ConfirmDelete()
    {
        _confirmDeleteOpen = true;
    }

    async Task DeleteServer()
    {
        _confirmDeleteOpen = false;

        await DeleteUseCase.ExecuteAsync(Laptop.Name);

        if (OnDeleted.HasDelegate)
            await OnDeleted.InvokeAsync(Laptop.Name);
    }

}

@code
{
    bool _renameOpen;

    void OpenRename()
    {
        _renameOpen = true;
    }

    async Task HandleRenameSubmit(string newName)
    {
        await RenameUseCase.ExecuteAsync(Laptop.Name, newName);
        Nav.NavigateTo($"resources/hardware/{Uri.EscapeDataString(newName)}");
    }

}

@code
{
    bool _cloneOpen;

    void OpenClone()
    {
        _cloneOpen = true;
    }

    async Task HandleCloneSubmit(string newName)
    {
        await CloneUseCase.ExecuteAsync(Laptop.Name, newName);

        Nav.NavigateTo($"resources/hardware/{Uri.EscapeDataString(newName)}");
    }

}


@code
{
    bool _editingNotes;
    string? _notesDraft;

    void BeginNotesEdit()
    {
        _editingNotes = true;
        _notesDraft = Laptop.Notes; // draft buffer
    }

    void CancelNotesEdit()
    {
        _editingNotes = false;
        _notesDraft = null; // discard
    }

    async Task SaveNotes()
    {
        _editingNotes = false;

        await UpdateUseCase.ExecuteAsync(
            Laptop.Name,
            Laptop.Model,
            Laptop.Ram?.Size,
            Laptop.Ram?.Mts,
            _notesDraft);

        Laptop = await GetByNameUseCase.ExecuteAsync(Laptop.Name);
        _notesDraft = null;
    }


}