RackPeek/RackPeek.Web/Components/Servers/ServerCardComponent.razor

@using RackPeek.Domain.Resources.Hardware.Models
@using RackPeek.Domain.Resources.Hardware.Servers
@using RackPeek.Domain.Resources.Hardware.Servers.Cpus
@using RackPeek.Domain.Resources.Hardware.Servers.Drives
@using RackPeek.Domain.Resources.Hardware.Servers.Gpus
@using RackPeek.Domain.Resources.Hardware.Servers.Nics
@using RackPeek.Web.Components.Modals
@inject AddCpuUseCase AddCpuUseCase
@inject RemoveCpuUseCase RemoveCpuUseCase
@inject UpdateCpuUseCase UpdateCpuUseCase

@inject AddDrivesUseCase AddDriveUseCase
@inject RemoveDriveUseCase RemoveDriveUseCase
@inject UpdateDriveUseCase UpdateDriveUseCase

@inject AddNicUseCase AddNicUseCase
@inject UpdateNicUseCase UpdateNicUseCase
@inject RemoveNicUseCase RemoveNicUseCase

@inject AddGpuUseCase AddGpuUseCase
@inject UpdateGpuUseCase UpdateGpuUseCase
@inject RemoveGpuUseCase RemoveGpuUseCase


@inject GetServerUseCase GetServerUseCase
@inject UpdateServerUseCase UpdateServerUseCase

<div class="border border-zinc-800 rounded p-4 bg-zinc-900">
    <div class="flex justify-between items-center mb-3">
        <div class="text-zinc-100">
            @Server.Name
        </div>

        @if (Server.Ipmi == true)
        {
            <span class="text-xs text-emerald-400">IPMI</span>
        }
    </div>

    <div class="grid grid-cols-1 md:grid-cols-2 gap-3 text-sm">
        
        <div>
            <div class="flex items-center justify-between mb-1 group">
                <div class="text-zinc-400">CPU
                    <button
                        class="hover:text-emerald-400 group-hover:opacity-100 transition"
                        title="Add CPU"
                        @onclick="OpenAddCpu">
                        +
                    </button>
                </div>
            </div>

            @if (Server.Cpus?.Any() == true)
            {
                <!-- CPU rows -->
                @foreach (var cpu in Server.Cpus)
                {
                    <div
                        class="flex items-center justify-between text-zinc-300 group hover:bg-zinc-800/40 rounded px-1 py-0.5">

                        <div class="flex gap-2 group-hover:opacity-100 transition">
                            <button
                                class="hover:text-emerald-400"
                                title="Edit CPU"
                                @onclick="() => OpenEditCpu(cpu)">
                                @cpu.Model — @cpu.Cores cores / @cpu.Threads threads
                            </button>
                        </div>
                    </div>
                }
            }
        </div>


        <div>
            <div class="text-zinc-400 mb-1">RAM
                @if (Server.Ram is null)
                {
                    <button
                        class="hover:text-emerald-400 group-hover:opacity-100 transition"
                        title="Add RAM"
                        @onclick="EditRam">
                        +
                    </button>
                }
            </div>
            @if (Server.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">
                    <div class="flex gap-2 group-hover:opacity-100 transition">
                        <button
                            class="hover:text-emerald-400"
                            title="Edit RAM"
                            @onclick="EditRam">
                            @($"{Server.Ram.Size} GB {@Server.Ram.Mts} MT/s")
                        </button>
                    </div>
                </div>
            }
        </div>


        <div>
            <div class="flex items-center justify-between mb-1 group">
                <div class="text-zinc-400">Drives
                    <button
                        class="hover:text-emerald-400 group-hover:opacity-100 transition"
                        title="Add Drive"
                        @onclick="OpenAddDrive">
                        +
                    </button>
                </div>
            </div>

            @if (Server.Drives?.Any() == true)
            {
                @foreach (var drive in Server.Drives)
                {
                    <div
                        class="flex items-center justify-between text-zinc-300 group hover:bg-zinc-800/40 rounded px-1 py-0.5">

                        <div class="flex gap-2 group-hover:opacity-100 transition">
                            <button
                                class="hover:text-emerald-400"
                                title="Edit Drive"
                                @onclick="() => OpenEditDrives(drive)">
                                @drive.Type — @drive.Size GB
                            </button>
                        </div>
                    </div>
                }
            }
        </div>
            
        <div>
            <div class="flex items-center justify-between mb-1 group">
                <div class="text-zinc-400">
                    NICs
                    <button
                        class="hover:text-emerald-400 group-hover:opacity-100 transition"
                        title="Add NIC"
                        @onclick="OpenAddNic">
                        +
                    </button>
                </div>
            </div>

            @if (Server.Nics?.Any() == true)
            {
                @foreach (var nic in Server.Nics)
                {
                    <div
                        class="flex items-center justify-between text-zinc-300 group hover:bg-zinc-800/40 rounded px-1 py-0.5">
                        <button
                            class="hover:text-emerald-400"
                            title="Edit NIC"
                            @onclick="() => OpenEditNic(nic)">
                            @nic.Type — @nic.Speed Gbps (@nic.Ports ports)
                        </button>
                    </div>
                }
            }
        </div>


        <div>
            <div class="flex items-center justify-between mb-1 group">
                <div class="text-zinc-400">
                    GPUs
                    <button
                        class="hover:text-emerald-400 group-hover:opacity-100 transition"
                        title="Add GPU"
                        @onclick="OpenAddGpu">
                        +
                    </button>
                </div>
            </div>

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


    </div>
</div>

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

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

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

<NicModal
    IsOpen="@_nicModalOpen"
    IsOpenChanged="v => _nicModalOpen = v"
    Value="@_editingNic"
    OnSubmit="HandleNicSubmit"
    OnDelete="HandleNicDelete" />

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


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

    #region RAM
    private bool _isRamModalOpen;
    private void EditRam()
    {
        _isRamModalOpen = true;
    }

    private async Task HandleRamSubmit(Ram value)
    {
        _isRamModalOpen = false;
        await UpdateServerUseCase.ExecuteAsync(Server.Name, value.Size, value.Mts, Server.Ipmi);
        Server = await GetServerUseCase.ExecuteAsync(Server.Name);
    }
    
    #endregion
    
    #region CPU
    bool _cpuModalOpen;
    int _editingCpuIndex;
    Cpu? _editingCpu;
    
    void OpenAddCpu()
    {
        _editingCpuIndex = -1;
        _editingCpu = null;
        _cpuModalOpen = true;
    }
    
    void OpenEditCpu(Cpu cpu)
    {
        _editingCpu = cpu;
        Server.Cpus ??= new();
        _editingCpuIndex = Server.Cpus.IndexOf(cpu);;
        _cpuModalOpen = true;
    }
    
    async Task HandleCpuSubmit(Cpu cpu)
    {
        Server.Cpus ??= new();

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

    async Task HandleCpuDelete(Cpu cpu)
    {
        await RemoveCpuUseCase.ExecuteAsync(Server.Name, _editingCpuIndex);
        Server = await GetServerUseCase.ExecuteAsync(Server.Name);
    }
    
        
    #endregion
    
    #region Drives
    bool _driveModalOpen;
    int _editingDriveIndex;
    Drive? _editingDrive;
    
    void OpenAddDrive()
    {
        _editingDriveIndex = -1;
        _editingDrive = null;
        _driveModalOpen = true;
    }
    
    void OpenEditDrives(Drive drive)
    {
        _editingDrive = drive;
        Server.Drives ??= new();
        _editingDriveIndex = Server.Drives.IndexOf(drive);;
        _driveModalOpen = true;
    }
    
    async Task HandleDriveSubmit(Drive drive)
    {
        Server.Drives ??= new();

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

    async Task HandleDriveDelete(Drive drive)
    {
        await RemoveDriveUseCase.ExecuteAsync(Server.Name, _editingDriveIndex);
        Server = await GetServerUseCase.ExecuteAsync(Server.Name);
        StateHasChanged();
    }
    
        
    #endregion
    
    #region NICs
    bool _nicModalOpen;
    int _editingNicIndex;
    Nic? _editingNic;

    void OpenAddNic()
    {
        _editingNicIndex = -1;
        _editingNic = null;
        _nicModalOpen = true;
    }

    void OpenEditNic(Nic nic)
    {
        Server.Nics ??= new();
        _editingNicIndex = Server.Nics.IndexOf(nic);
        _editingNic = nic;
        _nicModalOpen = true;
    }

    async Task HandleNicSubmit(Nic nic)
    {
        Server.Nics ??= new();

        if (_editingNicIndex < 0)
        {
            await AddNicUseCase.ExecuteAsync(
                Server.Name,
                nic.Type,
                nic.Speed,
                nic.Ports);
        }
        else
        {
            await UpdateNicUseCase.ExecuteAsync(
                Server.Name,
                _editingNicIndex,
                nic.Type,
                nic.Speed,
                nic.Ports);
        }

        Server = await GetServerUseCase.ExecuteAsync(Server.Name);
    }

    async Task HandleNicDelete(Nic nic)
    {
        await RemoveNicUseCase.ExecuteAsync(Server.Name, _editingNicIndex);
        Server = await GetServerUseCase.ExecuteAsync(Server.Name);
    }
    #endregion

    #region GPUs
    bool _gpuModalOpen;
    int _editingGpuIndex;
    Gpu? _editingGpu;

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

    void OpenEditGpu(Gpu gpu)
    {
        Server.Gpus ??= new();
        _editingGpuIndex = Server.Gpus.IndexOf(gpu);
        _editingGpu = gpu;
        _gpuModalOpen = true;
    }

    async Task HandleGpuSubmit(Gpu gpu)
    {
        Server.Gpus ??= new();

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

        Server = await GetServerUseCase.ExecuteAsync(Server.Name);
    }

    async Task HandleGpuDelete(Gpu gpu)
    {
        await RemoveGpuUseCase.ExecuteAsync(Server.Name, _editingGpuIndex);
        Server = await GetServerUseCase.ExecuteAsync(Server.Name);
    }
    #endregion

}