@page "/shared/{token}"
@using PlaylistShared.Pwa.Components.SharedPlaylist
@using PlaylistShared.Shared.DTO
@using PlaylistShared.Shared.Enums
@using PlaylistShared.Pwa.Services
@using PlaylistShared.Shared.Shared
@inject HttpClient Http
@inject ISnackbar Snackbar
@inject NavigationManager Navigation
@inject AuthenticationStateProvider AuthProvider
@inject IDialogService DialogService

<MudContainer MaxWidth="MaxWidth.Large" Class="mt-8">
    @if (_loading)
    {
        <MudProgressCircular Indeterminate />
    }
    else if (_playlist == null)
    {
        <MudAlert Severity="Severity.Error">Плейлист не найден или у вас нет доступа</MudAlert>
    }
    else
    {
        <MudCard>
            <!-- Заголовок с обложкой -->
            <MudCardHeader>
                <CardHeaderContent>
                    <PlaylistHeader Playlist="@_playlist" />
                </CardHeaderContent>
            </MudCardHeader>

            <MudCardContent>
                @if (_canAdd)
                {
                    <AddTrackSection ShareToken="@Token"
                                     OnTrackAdded="LoadTracks"
                                     OnPlayTrack="PlayTrack"
                                     CurrentPlayingTrackId="_currentTrackId"
                                     IsPlaying="_isPlaying" />
                }

                <!-- Список треков -->
                <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 16px;">
                    <MudText Typo="Typo.h6">Треки</MudText>
                    <MudIconButton Icon="@Icons.Material.Filled.Refresh" OnClick="LoadTracks" Disabled="_tracksLoading" Size="Size.Medium" />
                </div>
                
                <TracksTable @ref="_tracksTableRef"
                             ShareToken="@Token"
                             CanPlay="@_canPlay"
                             CanRemove="@_canRemove"
                             CurrentPlayingTrackId="_currentTrackId"
                             IsPlaying="_isPlaying"
                             OnPlayTrack="PlayTrack" />
            </MudCardContent>
        </MudCard>
    }

    <!-- Фиксированный плеер внизу -->
    <div class="fixed-player" style="display: @(_isPlayerVisible ? "block" : "none");">
        <AudioPlayer @ref="_audioPlayer" OnTrackEnded="OnTrackEnded" RequireAuth="false" SharedPlaylistId="@Token" />
    </div>
</MudContainer>


@code {
    [Parameter] public string Token { get; set; }

    private int _addTrackTabIndex = 0; // 0 - ссылка, 1 - поиск

    private AudioPlayer? _audioPlayer;
    private TracksTable? _tracksTableRef;
    private string? _currentTrackId { get; set; }
    private bool _isPlaying = false;
    private bool _isPlayerVisible = false;

    private SharedPlaylistDto? _playlist;
    private bool _loading = true;
    private bool _isAuthenticated;
    private bool _isCreator;
    private bool _canPlay;
    private bool _canAdd;
    private bool _canRemove;
    private UpdatePermissionsDto _editPermissions = new();
    private bool _savingPermissions;
    private string? _currentUserId;

    private bool _isFavorite = false;
    private bool _favoriteLoading = false;
    private bool _tracksLoading;

    private string _trackLink = "";
    private bool _addingTrack;

    protected override async Task OnInitializedAsync()
    {
        var authState = await AuthProvider.GetAuthenticationStateAsync();
        _isAuthenticated = authState.User.Identity?.IsAuthenticated == true;
        _currentUserId = authState.User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value;
        await LoadPlaylist();
    }

    private async Task ConfigurePermissions()
    {
        if (_playlist is null)
        {
            _isCreator = false;
            _canAdd = false;
            _canRemove = false;
            _canPlay = false;
        }
        else
        {
            _isCreator = _playlist.CreatorUserId.ToString() == _currentUserId;

            _canAdd = _isCreator
            || _playlist.AddPermission == EditPermission.Everyone
            || (_playlist.AddPermission == EditPermission.AuthorizedOnly && _isAuthenticated);

            _canRemove = _isCreator
            || _playlist.RemovePermission == EditPermission.Everyone
            || (_playlist.RemovePermission == EditPermission.AuthorizedOnly && _isAuthenticated);

            _canPlay = _isCreator
            || _playlist.PlayPermission == ViewPermission.Everyone
            || (_playlist.PlayPermission == ViewPermission.AuthorizedOnly && _isAuthenticated);

            if (_isCreator && _isAuthenticated)
            {
                _editPermissions = new UpdatePermissionsDto
                {
                    ViewPermission = _playlist.ViewPermission,
                    AddPermission = _playlist.AddPermission,
                    RemovePermission = _playlist.RemovePermission,
                    PlayPermission = _playlist.PlayPermission,
                };
            }

        }
    }

    private async Task LoadPlaylist()
    {
        try
        {
            var response = await Http.GetFromJsonAsync<ApiResponse<SharedPlaylistDto>>($"/api/sharedplaylist/{Token}");
            if (response?.Success == true)
            {
                _playlist = response.Data;

                await ConfigurePermissions();
                //await LoadTracks();
            }
            else
            {
                Snackbar.Add(response?.Error?.Message ?? "Не удалось загрузить плейлист", Severity.Error);
            }
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Ошибка: {ex.Message}", Severity.Error);
        }
        finally
        {
            _loading = false;
            StateHasChanged();
        }
    }

    private async Task LoadTracks()
    {
        if (_playlist == null) return;
        if (_tracksTableRef == null) return;

        _tracksLoading = true;
        StateHasChanged();

        await _tracksTableRef.Reload();

        _tracksLoading = false;
        StateHasChanged();
    }

    private async Task PlayTrack(string trackId)
    {
        if (_audioPlayer == null) return;

        if (_currentTrackId == trackId && _isPlaying)
        {
            await _audioPlayer.PauseAsync();
            _isPlaying = false;
        }
        else if (_currentTrackId == trackId && !_isPlaying)
        {
            await _audioPlayer.PlayAsync();
            _isPlaying = true;
        }
        else
        {
            if (!string.IsNullOrEmpty(_currentTrackId) && _isPlaying)
                await _audioPlayer.StopAsync();

            _currentTrackId = trackId;
            await _audioPlayer.LoadAndPlayAsync(trackId);
            _isPlaying = true;
        }

        _isPlayerVisible = true;
    }

    private async Task OnTrackEnded()
    {
        _currentTrackId = null;
        _isPlaying = false;
        StateHasChanged();
    }
}