KoogleApp/src/Koogle.Web/Components/Pages/Account/ClubSetup.razor

@page "/account/club-setup"

@using Koogle.Application.DTOs
@using Koogle.Application.Interfaces
@using Koogle.Domain.Enums

@inject IUserService UserService
@inject IClubService ClubService
@inject IClubRequestService ClubRequestService
@inject NavigationManager NavigationManager

@attribute [Microsoft.AspNetCore.Authorization.Authorize]

<MudContainer MaxWidth="MaxWidth.Small" Class="mt-6">
    <MudPaper Class="pa-6" Elevation="4">
        <MudText Typo="Typo.h5" Class="mb-4">Club-Einrichtung</MudText>

        <MudText Class="mb-4">
            Du bist noch keinem Club zugeordnet. Wähle eine Option:
        </MudText>

        <MudTabs Elevation="0" Rounded="true" ApplyEffectsToContainer="true" Class="mb-4">
            <MudTabPanel Text="Club beitreten">
                <MudStack Class="pa-4">
                    <MudText Typo="Typo.body1" Class="mb-3">
                        Suche einen bestehenden Club und stelle eine Beitrittsanfrage.
                    </MudText>

                    <MudAutocomplete T="ClubDto"
                        Label="Club suchen"
                        @bind-Value="_selectedClub"
                        SearchFunc="SearchClubsAsync"
                        ToStringFunc="@(c => c?.Name ?? "")"
                        Variant="Variant.Outlined"
                        ShowProgressIndicator="true"
                        MinCharacters="1"
                        Class="mb-3" />

                    <MudButton Variant="Variant.Filled"
                        Color="Color.Primary"
                        OnClick="RequestMembershipAsync"
                        Disabled="@(_selectedClub == null || _isLoading)">
                        @if (_isLoading)
                        {
                            <MudProgressCircular Size="Size.Small" Indeterminate="true" Class="mr-2" />
                        }
                        Mitgliedschaft anfragen
                    </MudButton>

                    @if (!string.IsNullOrEmpty(_joinMessage))
                    {
                        <MudAlert Severity="@_joinSeverity" Class="mt-3">@_joinMessage</MudAlert>
                    }
                </MudStack>
            </MudTabPanel>

            <MudTabPanel Text="Club gründen">
                <MudStack Class="pa-4">
                    <MudText Typo="Typo.body1" Class="mb-3">
                        Beantrage einen neuen Club. Die Freigabe erfolgt durch einen Administrator.
                    </MudText>

                    <MudTextField T="string"
                        @bind-Value="_newClubName"
                        Label="Club-Name"
                        Variant="Variant.Outlined"
                        Required="true"
                        Class="mb-3" />

                    <MudTextField T="string"
                        @bind-Value="_newClubLoginName"
                        Label="Login-Name"
                        Variant="Variant.Outlined"
                        Required="true"
                        HelperText="Eindeutiger Kurzname (z.B. meinclub)"
                        Style="text-transform: lowercase;"
                        Class="mb-3" />

                    <MudButton Variant="Variant.Filled"
                        Color="Color.Primary"
                        OnClick="CreateClubRequestAsync"
                        Disabled="@(string.IsNullOrWhiteSpace(_newClubName) || string.IsNullOrWhiteSpace(_newClubLoginName) || _isLoading)">
                        @if (_isLoading)
                        {
                            <MudProgressCircular Size="Size.Small" Indeterminate="true" Class="mr-2" />
                        }
                        Club beantragen
                    </MudButton>

                    @if (!string.IsNullOrEmpty(_createMessage))
                    {
                        <MudAlert Severity="@_createSeverity" Class="mt-3">@_createMessage</MudAlert>
                    }
                </MudStack>
            </MudTabPanel>
        </MudTabs>

        @if (_pendingMemberships.Count > 0 || _pendingClubRequests.Count > 0)
        {
            <MudDivider Class="my-4" />
            <MudText Typo="Typo.h6" Class="mb-3">Offene Anfragen</MudText>

            @foreach (var membership in _pendingMemberships)
            {
                <MudAlert Severity="Severity.Info" Class="mb-2">
                    Beitrittsanfrage für <strong>@membership.ClubName</strong> wartet auf Freigabe
                </MudAlert>
            }

            @foreach (var request in _pendingClubRequests)
            {
                <MudAlert Severity="Severity.Info" Class="mb-2">
                    Club-Antrag für <strong>@request.Name</strong> wartet auf Freigabe
                </MudAlert>
            }
        }
    </MudPaper>
</MudContainer>

@code {
    private ClubDto? _selectedClub;
    private string _newClubName = "";
    private string _newClubLoginName = "";
    private bool _isLoading;

    private string? _joinMessage;
    private Severity _joinSeverity;
    private string? _createMessage;
    private Severity _createSeverity;

    private List<UserClubMembershipDto> _pendingMemberships = [];
    private List<ClubRequestDto> _pendingClubRequests = [];
    private UserDto? _currentUser;

    protected override async Task OnInitializedAsync()
    {
        _currentUser = await UserService.GetCurrentUserAsync();
        if (_currentUser != null)
        {
            // Load pending memberships
            _pendingMemberships = _currentUser.ClubMemberships
                .Where(m => m.Status == MembershipStatus.Pending)
                .ToList();

            // Load pending club requests
            _pendingClubRequests = (await ClubRequestService.GetRequestsByUserAsync(_currentUser.ProfileId))
                .Where(r => r.Status == ClubRequestStatus.Pending)
                .ToList();
        }
    }

    private async Task<IEnumerable<ClubDto>> SearchClubsAsync(string value, CancellationToken ct)
    {
        if (string.IsNullOrWhiteSpace(value))
            return [];

        var clubs = await ClubService.GetAllAsync(ct);
        return clubs.Where(c => c.Name.Contains(value, StringComparison.OrdinalIgnoreCase))
            .Take(10);
    }

    private async Task RequestMembershipAsync()
    {
        if (_selectedClub == null || _currentUser == null)
            return;

        _isLoading = true;
        _joinMessage = null;

        try
        {
            var success = await UserService.RequestClubMembershipAsync(_currentUser.ProfileId, _selectedClub.Id);
            if (success)
            {
                _joinMessage = "Beitrittsanfrage wurde gestellt. Du wirst per E-Mail benachrichtigt.";
                _joinSeverity = Severity.Success;
                _selectedClub = null;

                // Reload pending memberships
                _currentUser = await UserService.GetCurrentUserAsync();
                if (_currentUser != null)
                {
                    _pendingMemberships = _currentUser.ClubMemberships
                        .Where(m => m.Status == MembershipStatus.Pending)
                        .ToList();
                }
            }
            else
            {
                _joinMessage = "Anfrage fehlgeschlagen. Möglicherweise besteht bereits eine Mitgliedschaft.";
                _joinSeverity = Severity.Error;
            }
        }
        catch (Exception ex)
        {
            _joinMessage = $"Fehler: {ex.Message}";
            _joinSeverity = Severity.Error;
        }
        finally
        {
            _isLoading = false;
        }
    }

    private async Task CreateClubRequestAsync()
    {
        if (string.IsNullOrWhiteSpace(_newClubName) || string.IsNullOrWhiteSpace(_newClubLoginName) || _currentUser == null)
            return;

        _isLoading = true;
        _createMessage = null;

        try
        {
            // Check if login name is taken
            if (await ClubRequestService.IsLoginNameTakenAsync(_newClubLoginName))
            {
                _createMessage = "Der Login-Name ist bereits vergeben.";
                _createSeverity = Severity.Error;
                return;
            }

            var dto = new CreateClubRequestDto
            {
                Name = _newClubName,
                LoginName = _newClubLoginName.ToLowerInvariant()
            };

            var request = await ClubRequestService.CreateRequestAsync(dto, _currentUser.ProfileId);
            _createMessage = "Club-Antrag wurde gestellt. Du wirst per E-Mail benachrichtigt.";
            _createSeverity = Severity.Success;
            _newClubName = "";
            _newClubLoginName = "";

            // Reload pending requests
            _pendingClubRequests = (await ClubRequestService.GetRequestsByUserAsync(_currentUser.ProfileId))
                .Where(r => r.Status == ClubRequestStatus.Pending)
                .ToList();
        }
        catch (Exception ex)
        {
            _createMessage = $"Fehler: {ex.Message}";
            _createSeverity = Severity.Error;
        }
        finally
        {
            _isLoading = false;
        }
    }
}