using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using SameBeat.Api.Hubs;
using SameBeat.Application.DTO;
using SameBeat.Application.Interfejsy;
using SameBeat.Application.Komendy;

namespace SameBeat.Api.Controllers;

/// <summary>
/// Sterowanie muzyka przez hosta (ETAP 4). Trasa zaczyna sie od "api/host", wiec jest automatycznie
/// chroniona [Authorize] przez KonwencjaAutoryzacjiHosta.
///
/// KONTEKST: muzyka NIE idzie przez LiveKit ani SignalR jako dzwiek -- kazda przegladarka (host i
/// kazdy widz) samodzielnie odtwarza TEN SAM plik audio spod Utwor.Url, a backend trzyma tylko
/// "zegar" (kiedy sie zaczelo, od ktorego miejsca) i widzowie synchronizuja swoja pozycje
/// odtwarzania do tego zegara. To jak radio internetowe.
///
/// Po kazdej akcji sterujacej zegarem rozsylamy "StanMuzykiZmieniony" (payload StanMuzykiDto) do
/// WSZYSTKICH klientow. Zmiany samej biblioteki/kolejki (dodanie/usuniecie utworu) rozsylamy jako
/// "MuzykaZmieniona" z aktualna kolejka (payload List&lt;PozycjaPlaylistyDto&gt;).
/// </summary>
[ApiController]
[Route("api/host/music")]
public class HostMusicController : ControllerBase
{
    private readonly ISerwisMuzyki _serwisMuzyki;
    private readonly IHubContext<StanImprezyHub> _hubKontekst;

    public HostMusicController(ISerwisMuzyki serwisMuzyki, IHubContext<StanImprezyHub> hubKontekst)
    {
        _serwisMuzyki = serwisMuzyki;
        _hubKontekst = hubKontekst;
    }

    [HttpPost("utwory")]
    public async Task<IActionResult> DodajUtworAsync([FromBody] DodajUtworKomenda komenda, CancellationToken token)
    {
        var wynik = await _serwisMuzyki.DodajUtworAsync(komenda, token);

        if (!wynik.Sukces || wynik.Dane is null)
        {
            return BadRequest(new { blad = wynik.Blad });
        }

        return Ok(wynik.Dane);
    }

    /// <summary>Cala biblioteka utworow -- do wyboru przy dodawaniu na playliste.</summary>
    [HttpGet("utwory")]
    public async Task<IActionResult> PobierzUtworyAsync(CancellationToken token)
    {
        var wynik = await _serwisMuzyki.PobierzUtworyAsync(token);

        if (!wynik.Sukces || wynik.Dane is null)
        {
            return BadRequest(new { blad = wynik.Blad });
        }

        return Ok(wynik.Dane);
    }

    [HttpPost("playlista/dodaj")]
    public async Task<IActionResult> DodajDoPlaylistyAsync([FromBody] DodajDoPlaylistyKomenda komenda, CancellationToken token)
    {
        var wynik = await _serwisMuzyki.DodajDoPlaylistyAsync(komenda.UtworId, token);

        if (!wynik.Sukces || wynik.Dane is null)
        {
            return BadRequest(new { blad = wynik.Blad });
        }

        await _hubKontekst.Clients.All.SendAsync("MuzykaZmieniona", wynik.Dane, cancellationToken: token);

        return Ok(wynik.Dane);
    }

    [HttpDelete("playlista/{pozycjaId:guid}")]
    public async Task<IActionResult> UsunZPlaylistyAsync(Guid pozycjaId, CancellationToken token)
    {
        var wynik = await _serwisMuzyki.UsunZPlaylistyAsync(pozycjaId, token);

        if (!wynik.Sukces || wynik.Dane is null)
        {
            return BadRequest(new { blad = wynik.Blad });
        }

        await _hubKontekst.Clients.All.SendAsync("MuzykaZmieniona", wynik.Dane, cancellationToken: token);

        return Ok(wynik.Dane);
    }

    /// <summary>Aktualna kolejka -- do wyswietlenia w panelu hosta po odswiezeniu strony.</summary>
    [HttpGet("playlista")]
    public async Task<IActionResult> PobierzPlaylisteAsync(CancellationToken token)
    {
        var wynik = await _serwisMuzyki.PobierzPlaylisteAsync(token);

        if (!wynik.Sukces || wynik.Dane is null)
        {
            return BadRequest(new { blad = wynik.Blad });
        }

        return Ok(wynik.Dane);
    }

    [HttpPost("play")]
    public async Task<IActionResult> OdtworzAsync([FromBody] OdtworzKomenda komenda, CancellationToken token)
    {
        var wynik = await _serwisMuzyki.OdtworzAsync(komenda.UtworId, token);
        return await RozglosStanMuzykiAsync(wynik, token);
    }

    [HttpPost("pause")]
    public async Task<IActionResult> WstrzymajAsync(CancellationToken token)
    {
        var wynik = await _serwisMuzyki.WstrzymajAsync(token);
        return await RozglosStanMuzykiAsync(wynik, token);
    }

    [HttpPost("next")]
    public async Task<IActionResult> NastepnyAsync(CancellationToken token)
    {
        var wynik = await _serwisMuzyki.NastepnyAsync(token);
        return await RozglosStanMuzykiAsync(wynik, token);
    }

    [HttpPost("poprzedni")]
    public async Task<IActionResult> PoprzedniAsync(CancellationToken token)
    {
        var wynik = await _serwisMuzyki.PoprzedniAsync(token);
        return await RozglosStanMuzykiAsync(wynik, token);
    }

    [HttpPost("glosnosc")]
    public async Task<IActionResult> UstawGlosnoscAsync([FromBody] UstawGlosnoscKomenda komenda, CancellationToken token)
    {
        var wynik = await _serwisMuzyki.UstawGlosnoscAsync(komenda.Wartosc, token);
        return await RozglosStanMuzykiAsync(wynik, token);
    }

    private async Task<IActionResult> RozglosStanMuzykiAsync(WynikOperacji<StanMuzykiDto> wynik, CancellationToken token)
    {
        if (!wynik.Sukces || wynik.Dane is null)
        {
            return BadRequest(new { blad = wynik.Blad });
        }

        await _hubKontekst.Clients.All.SendAsync("StanMuzykiZmieniony", wynik.Dane, cancellationToken: token);

        return Ok(wynik.Dane);
    }
}