@using PlaylistShared.Pwa.Components.Common
@using PlaylistShared.Shared.DTO
@using PlaylistShared.Shared.Enums
@using PlaylistShared.Shared.SharedPlaylist
@inject HttpClient Http
@inject ISnackbar Snackbar

<MudPaper Class="mb-4" Elevation="0" Style="background-color: rgba(0,0,0,0.05); border-radius: 8px;">
    <MudStack AlignItems="AlignItems.Start">
        <MudTextField @bind-Value="_searchQuery"
                      @bind-Value:after="SearchTracks"
                      Variant="Variant.Outlined"
                      FullWidth
                      Label="Название или ссылка на трек Яндекс.Музыки"
                      Disabled="@_isSearching"
                      Adornment="Adornment.End" AdornmentIcon="@Icons.Material.Filled.Search" AdornmentColor="Color.Secondary"
                      />

        <MudToggleGroup T="TrackSearchType"
                        @bind-Value="_searchType"
                        @bind-Value:after="SearchTracks"
                        Size="Size.Small"
                        Color="Color.Primary"
                        Disabled="@(_isSearching)"
                        >
            <MudToggleItem Value="TrackSearchType.All" Text="Все" />
            <MudToggleItem Value="TrackSearchType.Track" Text="Трек" />
            <MudToggleItem Value="TrackSearchType.Album" Text="Альбом" />
            <MudToggleItem Value="TrackSearchType.Artist" Text="Исполнитель" />
        </MudToggleGroup>

        @if (_isSearching)
        {
            <MudProgressLinear Color="Color.Primary" Indeterminate="true" Class="my-7" />
        }
        else if (_searchResults.Any())
        {
            <div style="max-height: 400px; overflow-y: auto;">
                @foreach (var track in _searchResults)
                {
                    <div style="display: flex; align-items: center; gap: 12px; padding: 8px; border-bottom: 1px solid rgba(0,0,0,0.1);">
                        <div style="width: 40px; height: 40px; flex-shrink: 0;">
                            <TrackCoverWithPlay CoverUrl="@track.CoverUri"
                                                TrackId="@track.TrackId"
                                                TrackTitle="@track.Title"
                                                PlaylistShareToken="@ShareToken"
                                                Width="40" Height="40" />
                        </div>
                        <div style="flex: 1; min-width: 0;">
                            <MudText Typo="Typo.body1" Style="font-weight: 500;">@track.Title</MudText>
                            <MudText Typo="Typo.body2" Color="Color.Secondary">@string.Join(", ", track.Artists)</MudText>
                        </div>
                        <div style="flex-shrink: 0;">
                            <MudText Typo="Typo.body2">@track.DurationMs.FormatDuration()</MudText>
                        </div>
                        <div style="flex-shrink: 0;">
                            <MudToggleIconButton Toggled="_addingTrackIds.Contains(track.TrackId)"
                                                 Icon="@Icons.Material.Filled.AddCircle"
                                                 Color="@Color.Primary"
                                                 ToggledIcon="@Icons.Material.Filled.RemoveCircle"
                                                 ToggledColor="@Color.Error"
                                                 ToggledChanged="() => ToggleTrack(track)" />
                        </div>
                    </div>
                }
            </div>
        }
        else if (!_isFirstSearch)
        {
            <MudAlert Severity="Severity.Info">Ничего не найдено. Попробуйте изменить запрос.</MudAlert>
        }
    </MudStack>
</MudPaper>

@code {
    [Parameter] public string ShareToken { get; set; } = string.Empty;
    [Parameter] public EventCallback OnTrackAdded { get; set; }
    [Parameter] public EventCallback OnTrackRemoved { get; set; }

    private string _searchQuery = "";
    private bool _isSearching = false;
    private bool _isFirstSearch = true;
    private TrackSearchType _searchType = TrackSearchType.All;
    private List<YandexTrack> _searchResults = new();
    private HashSet<string> _addingTrackIds = new();

    private async Task SearchTracks()
    {
        if (string.IsNullOrWhiteSpace(_searchQuery))
        {
            return;
        }

        var query = _searchQuery.Trim();
        var type = _searchType;
        bool byId = false;

        if (Uri.TryCreate(_searchQuery, UriKind.Absolute, out var uri) && uri.Host == "music.yandex.ru")
        {
            try
            {
                (type, query) = ParseYandexMusicUrl(uri);
                byId = true;
            }
            catch (Exception ex)
            {
                Snackbar.Add($"Ошибка распознавания URL: {ex.Message}", Severity.Error);
                return;
            }
        }

        _isFirstSearch = false;
        _isSearching = true;
        try
        {
            var url = $"/api/yandexsearch/tracks?query={Uri.EscapeDataString(query)}&type={Uri.EscapeDataString(type.ToString())}&limit=20";
            if (!string.IsNullOrEmpty(ShareToken))
                url += $"&shared_id={Uri.EscapeDataString(ShareToken)}";
            if (byId)
                url += $"&byId={byId}";

            var response = await Http.GetFromJsonAsync<ApiResponse<List<YandexTrack>>>(url);
            if (response?.Success == true)
                _searchResults = response.Data ?? new();
            else
                Snackbar.Add(response?.Error?.Message ?? "Ошибка поиска", Severity.Error);
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Ошибка: {ex.Message}", Severity.Error);
        }
        finally
        {
            _isSearching = false;
            StateHasChanged();
        }

    }

    private async Task SearchTracksByQuery(string query)
    {
        if (string.IsNullOrWhiteSpace(query))
            return;

    }

    private async Task ToggleTrack(YandexTrack track)
    {
        if (_addingTrackIds.Contains(track.TrackId))
        {
            await RemoveTrack(track);
        }
        else
        {
            await AddTrack(track);
        }
    }

    private async Task RemoveTrack(YandexTrack track)
    {
        if (!_addingTrackIds.Remove(track.TrackId)) return;
        

        try
        {
            await RemoveTrackById(track.TrackId);
            await OnTrackRemoved.InvokeAsync();
            Snackbar.Add($"Трек \"{track.Title}\" добавлен", Severity.Success);
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Ошибка добавления: {ex.Message}", Severity.Error);
            _addingTrackIds.Add(track.TrackId);
        }
        finally
        {
            StateHasChanged();
        }
    }

    private async Task AddTrack(YandexTrack track)
    {
        if (_addingTrackIds.Contains(track.TrackId)) return;
        _addingTrackIds.Add(track.TrackId);

        try
        {
            await AddTrackById(track.TrackId);
            await OnTrackAdded.InvokeAsync();
            Snackbar.Add($"Трек \"{track.Title}\" добавлен", Severity.Success);
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Ошибка добавления: {ex.Message}", Severity.Error);
            _addingTrackIds.Remove(track.TrackId);
        }
        finally
        {
            StateHasChanged();
        }
    }

    private async Task AddTrackById(string trackId)
    {
        try
        {
            var request = new UpdateTrackListRequest { TrackIds = new List<string> { trackId } };
            var response = await Http.PostAsJsonAsync($"/api/sharedplaylist/{ShareToken}/add-tracks", request);
            if (response.IsSuccessStatusCode)
            {
                Snackbar.Add("Трек успешно добавлен", Severity.Success);
                await OnTrackAdded.InvokeAsync(); // уведомляем родителя, что список треков изменился
            }
            else
            {
                var error = await response.Content.ReadFromJsonAsync<ApiResponse<object>>();
                Snackbar.Add(error?.Error?.Message ?? "Ошибка добавления трека", Severity.Error);
            }
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Ошибка: {ex.Message}", Severity.Error);
        }
        finally
        {
            StateHasChanged();
        }
    }

    private async Task RemoveTrackById(string trackId)
    {
        try
        {
            var request = new UpdateTrackListRequest { TrackIds = new List<string> { trackId } };
            var response = await Http.PostAsJsonAsync($"/api/sharedplaylist/{ShareToken}/remove-tracks", request);
            if (response.IsSuccessStatusCode)
            {
                Snackbar.Add("Трек успешно удален", Severity.Success);
                await OnTrackAdded.InvokeAsync(); // уведомляем родителя, что список треков изменился
            }
            else
            {
                var error = await response.Content.ReadFromJsonAsync<ApiResponse<object>>();
                Snackbar.Add(error?.Error?.Message ?? "Ошибка удаления трека", Severity.Error);
            }
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Ошибка: {ex.Message}", Severity.Error);
        }
        finally
        {
            StateHasChanged();
        }
    }

    private static (TrackSearchType Type, string Id) ParseYandexMusicUrl(Uri uri)
    {
        var segments = uri.AbsolutePath.Split('/', StringSplitOptions.RemoveEmptyEntries);
        
        var dataMap = segments
            .Select((val, idx) => new { val, idx })
            .GroupBy(x => x.idx / 2)
            .ToDictionary(
                g => g.First().val,
                g => g.ElementAtOrDefault(1)?.val
            );

        if (dataMap.TryGetValue("track", out var trackId) && !string.IsNullOrEmpty(trackId))
            return (TrackSearchType.Track, trackId);
        if (dataMap.TryGetValue("album", out var albumId) && !string.IsNullOrEmpty(albumId))
            return (TrackSearchType.Album, albumId);
        if (dataMap.TryGetValue("playlist", out var playlistId) && !string.IsNullOrEmpty(playlistId))
            return (TrackSearchType.Playlist, playlistId);
        if (dataMap.TryGetValue("artist", out var artistId) && !string.IsNullOrEmpty(artistId))
            return (TrackSearchType.Artist, artistId);

        throw new ArgumentException("Unsupported URL pattern");
    }
}