using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using DeepDrftModels.DTOs;
using DeepDrftModels.Enums;
using Models.Common;
using NetBlocks.Models;

namespace DeepDrftManager.Services;

/// <summary>
/// HTTP client over the DeepDrftAPI API for all CMS track operations. The Manager is
/// InteractiveServer-only and holds no in-process data layer: every track read and write is a
/// network call to DeepDrftAPI, which is the single authority over both the SQL metadata
/// store and the binary audio vault. The ApiKey is baked into the <c>DeepDrft.Content.Cms</c>
/// named client's default headers.
/// </summary>
public class CmsTrackService : ICmsTrackService
{
    private const string ContentCmsClientName = "DeepDrft.Content.Cms";
    private const string UploadPath = "api/track/upload";

    private readonly IHttpClientFactory _httpClientFactory;
    private readonly ILogger<CmsTrackService> _logger;

    public CmsTrackService(
        IHttpClientFactory httpClientFactory,
        ILogger<CmsTrackService> logger)
    {
        _httpClientFactory = httpClientFactory;
        _logger = logger;
    }

    public async Task<ResultContainer<TrackDto>> UploadTrackAsync(
        Stream wavStream,
        string fileName,
        string contentType,
        string trackName,
        string artist,
        string? album,
        string? genre,
        string? releaseDate,
        string? originalFileName,
        long createdByUserId,
        ReleaseType releaseType,
        int trackNumber,
        ReleaseMedium medium = ReleaseMedium.Cut,
        CancellationToken ct = default)
    {
        // Rebuild the multipart container so the boundary is owned by HttpClient and the
        // caller-supplied stream (already buffered by the SignalR upload) is the source.
        using var multipart = new MultipartFormDataContent();
        var wavContent = new StreamContent(wavStream);
        wavContent.Headers.ContentType = new MediaTypeHeaderValue(
            string.IsNullOrWhiteSpace(contentType) ? "audio/wav" : contentType);
        multipart.Add(wavContent, "audioFile", fileName);
        multipart.Add(new StringContent(trackName), "trackName");
        multipart.Add(new StringContent(artist), "artist");
        if (!string.IsNullOrWhiteSpace(album)) multipart.Add(new StringContent(album), "album");
        if (!string.IsNullOrWhiteSpace(genre)) multipart.Add(new StringContent(genre), "genre");
        if (!string.IsNullOrWhiteSpace(releaseDate)) multipart.Add(new StringContent(releaseDate), "releaseDate");
        // Explicit field — decouples the admin-visible display name from the WAV part's content-disposition filename.
        if (!string.IsNullOrWhiteSpace(originalFileName)) multipart.Add(new StringContent(originalFileName), "originalFileName");
        multipart.Add(new StringContent(createdByUserId.ToString()), "createdByUserId");
        multipart.Add(new StringContent(releaseType.ToString()), "releaseType");
        multipart.Add(new StringContent(trackNumber.ToString()), "trackNumber");
        // The upload endpoint binds "medium" to the created release's ReleaseMedium (defaulting to Cut
        // for an unrecognised value). Authoritative only when this upload creates the release.
        multipart.Add(new StringContent(medium.ToString()), "medium");

        var client = _httpClientFactory.CreateClient(ContentCmsClientName);
        using var request = new HttpRequestMessage(HttpMethod.Post, UploadPath) { Content = multipart };

        HttpResponseMessage response;
        try
        {
            response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for upload of {TrackName}", trackName);
            return ResultContainer<TrackDto>.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (!response.IsSuccessStatusCode)
            {
                var body = await response.Content.ReadAsStringAsync(ct);
                var statusCode = (int)response.StatusCode;
                if (statusCode >= 500)
                {
                    _logger.LogError("Content API returned {Status} for upload of {TrackName}: {Body}", statusCode, trackName, body);
                    return ResultContainer<TrackDto>.CreateFailResult("Upload failed on the content server. Please try again.");
                }

                // 4xx: body is user-friendly validation text from DeepDrftAPI — relay as-is.
                _logger.LogWarning("Content API rejected upload: {Status} {Body}", statusCode, body);
                return ResultContainer<TrackDto>.CreateFailResult(
                    string.IsNullOrWhiteSpace(body) ? $"Upload rejected ({statusCode})." : body);
            }

            // The Content API now owns the dual-database write, so the response is the persisted
            // track DTO (Id > 0) — no SQL roundtrip here.
            TrackDto? persisted;
            try
            {
                persisted = await response.Content.ReadFromJsonAsync<TrackDto>(ct);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to deserialize TrackDto from Content API response");
                return ResultContainer<TrackDto>.CreateFailResult("Content API returned an unexpected response.");
            }

            if (persisted is null)
            {
                _logger.LogError("Content API returned a null TrackDto");
                return ResultContainer<TrackDto>.CreateFailResult("Content API returned an empty response.");
            }

            return ResultContainer<TrackDto>.CreatePassResult(persisted);
        }
    }

    public async Task<Result> DeleteTrackAsync(long id, CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);

        HttpResponseMessage response;
        try
        {
            response = await client.DeleteAsync($"api/track/{id}", ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for delete of track {TrackId}", id);
            return Result.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (response.IsSuccessStatusCode)
            {
                return Result.CreatePassResult();
            }

            if (response.StatusCode == HttpStatusCode.NotFound)
            {
                return Result.CreateFailResult("Track not found.");
            }

            var body = await response.Content.ReadAsStringAsync(ct);
            _logger.LogError("Content API delete failed for track {TrackId}: {Status} {Body}", id, (int)response.StatusCode, body);
            return Result.CreateFailResult("Failed to delete track.");
        }
    }

    public async Task<Result> DeleteReleaseAsync(long releaseId, CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);

        HttpResponseMessage response;
        try
        {
            response = await client.DeleteAsync($"api/track/release/{releaseId}", ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for delete of release {ReleaseId}", releaseId);
            return Result.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (response.IsSuccessStatusCode)
            {
                return Result.CreatePassResult();
            }

            if (response.StatusCode == HttpStatusCode.NotFound)
            {
                return Result.CreateFailResult("Release not found.");
            }

            var body = await response.Content.ReadAsStringAsync(ct);
            _logger.LogError("Content API delete failed for release {ReleaseId}: {Status} {Body}", releaseId, (int)response.StatusCode, body);
            return Result.CreateFailResult("Failed to delete release.");
        }
    }

    public async Task<ResultContainer<PagedResult<TrackDto>>> GetPagedAsync(
        int page, int pageSize, string? sortColumn, bool sortDescending,
        string? album = null, string? genre = null,
        CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);
        var query = $"api/track/page?page={page}&pageSize={pageSize}&sortDescending={sortDescending}";
        if (!string.IsNullOrWhiteSpace(sortColumn))
        {
            query += $"&sortColumn={Uri.EscapeDataString(sortColumn)}";
        }
        if (!string.IsNullOrWhiteSpace(album))
        {
            query += $"&album={Uri.EscapeDataString(album)}";
        }
        if (!string.IsNullOrWhiteSpace(genre))
        {
            query += $"&genre={Uri.EscapeDataString(genre)}";
        }

        HttpResponseMessage response;
        try
        {
            response = await client.GetAsync(query, ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for track page");
            return ResultContainer<PagedResult<TrackDto>>.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (!response.IsSuccessStatusCode)
            {
                _logger.LogError("Content API track page failed: {Status}", (int)response.StatusCode);
                return ResultContainer<PagedResult<TrackDto>>.CreateFailResult("Failed to load tracks.");
            }

            PagedResult<TrackDto>? paged;
            try
            {
                paged = await response.Content.ReadFromJsonAsync<PagedResult<TrackDto>>(ct);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to deserialize PagedResult from Content API response");
                return ResultContainer<PagedResult<TrackDto>>.CreateFailResult("Content API returned an unexpected response.");
            }

            if (paged is null)
            {
                _logger.LogError("Content API returned a null PagedResult");
                return ResultContainer<PagedResult<TrackDto>>.CreateFailResult("Content API returned an empty response.");
            }

            return ResultContainer<PagedResult<TrackDto>>.CreatePassResult(paged);
        }
    }

    public async Task<ResultContainer<TrackDto?>> GetByIdAsync(long id, CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);

        HttpResponseMessage response;
        try
        {
            response = await client.GetAsync($"api/track/meta/{id}", ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for track {TrackId}", id);
            return ResultContainer<TrackDto?>.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (response.StatusCode == HttpStatusCode.NotFound)
            {
                return ResultContainer<TrackDto?>.CreatePassResult(null);
            }

            if (!response.IsSuccessStatusCode)
            {
                _logger.LogError("Content API track lookup failed for {TrackId}: {Status}", id, (int)response.StatusCode);
                return ResultContainer<TrackDto?>.CreateFailResult("Failed to load track.");
            }

            TrackDto? track;
            try
            {
                track = await response.Content.ReadFromJsonAsync<TrackDto>(ct);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to deserialize TrackDto from Content API response");
                return ResultContainer<TrackDto?>.CreateFailResult("Content API returned an unexpected response.");
            }

            return ResultContainer<TrackDto?>.CreatePassResult(track);
        }
    }

    private static readonly HashSet<string> KnownImageMimeTypes = new(StringComparer.OrdinalIgnoreCase)
    {
        "image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml", "image/bmp"
    };

    public async Task<ResultContainer<string>> UploadImageAsync(
        Stream imageStream,
        string fileName,
        string contentType,
        CancellationToken ct = default)
    {
        if (string.IsNullOrWhiteSpace(contentType) || !KnownImageMimeTypes.Contains(contentType))
        {
            _logger.LogWarning("UploadImageAsync rejected: unsupported or missing content type '{ContentType}'", contentType);
            return ResultContainer<string>.CreateFailResult($"Unsupported image type: {contentType}. Accepted: JPEG, PNG, GIF, WebP, SVG, BMP.");
        }

        using var multipart = new MultipartFormDataContent();
        var imageContent = new StreamContent(imageStream);
        imageContent.Headers.ContentType = new MediaTypeHeaderValue(contentType);
        multipart.Add(imageContent, "image", fileName);

        var client = _httpClientFactory.CreateClient(ContentCmsClientName);
        using var request = new HttpRequestMessage(HttpMethod.Post, "api/image/upload") { Content = multipart };

        HttpResponseMessage response;
        try
        {
            response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for image upload of {FileName}", fileName);
            return ResultContainer<string>.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (!response.IsSuccessStatusCode)
            {
                var body = await response.Content.ReadAsStringAsync(ct);
                var statusCode = (int)response.StatusCode;
                if (statusCode >= 500)
                {
                    _logger.LogError("Content API returned {Status} for image upload of {FileName}: {Body}", statusCode, fileName, body);
                    return ResultContainer<string>.CreateFailResult("Image upload failed on the content server.");
                }

                // 4xx: body is user-friendly validation text from DeepDrftAPI — relay as-is.
                _logger.LogWarning("Content API rejected image upload: {Status} {Body}", statusCode, body);
                return ResultContainer<string>.CreateFailResult(
                    string.IsNullOrWhiteSpace(body) ? $"Image upload rejected ({statusCode})." : body);
            }

            ImageUploadResponse? payload;
            try
            {
                payload = await response.Content.ReadFromJsonAsync<ImageUploadResponse>(ct);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to deserialize image upload response from Content API");
                return ResultContainer<string>.CreateFailResult("Content API returned an unexpected response.");
            }

            if (payload is null || string.IsNullOrWhiteSpace(payload.EntryKey))
            {
                _logger.LogError("Content API returned an empty entry key for image upload");
                return ResultContainer<string>.CreateFailResult("Content API returned an empty response.");
            }

            return ResultContainer<string>.CreatePassResult(payload.EntryKey);
        }
    }

    private sealed record ImageUploadResponse(string EntryKey);

    public async Task<Result> UpdateAsync(
        long id, string trackName, string artist,
        string? album, string? genre, DateOnly? releaseDate,
        string? imagePath = null,
        ReleaseType? releaseType = null,
        ReleaseMedium? medium = null,
        int? trackNumber = null,
        CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);
        var body = new
        {
            trackName,
            artist,
            album,
            genre,
            releaseDate,
            imagePath,
            releaseType = releaseType.HasValue ? (int?)releaseType.Value : null,
            medium = medium.HasValue ? (int?)medium.Value : null,
            trackNumber,
        };

        HttpResponseMessage response;
        try
        {
            response = await client.PutAsJsonAsync($"api/track/meta/{id}", body, ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for update of track {TrackId}", id);
            return Result.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (response.IsSuccessStatusCode)
            {
                return Result.CreatePassResult();
            }

            if (response.StatusCode == HttpStatusCode.NotFound)
            {
                return Result.CreateFailResult("Track not found.");
            }

            var responseBody = await response.Content.ReadAsStringAsync(ct);
            _logger.LogError("Content API update failed for track {TrackId}: {Status} {Body}", id, (int)response.StatusCode, responseBody);
            return Result.CreateFailResult("Failed to update track.");
        }
    }

    public async Task<ResultContainer<WaveformStatusDto[]>> GetWaveformStatusAsync(CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);

        HttpResponseMessage response;
        try
        {
            response = await client.GetAsync("api/track/waveform-status", ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for waveform status");
            return ResultContainer<WaveformStatusDto[]>.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (!response.IsSuccessStatusCode)
            {
                _logger.LogError("Content API waveform status failed: {Status}", (int)response.StatusCode);
                return ResultContainer<WaveformStatusDto[]>.CreateFailResult("Failed to load waveform status.");
            }

            WaveformStatusDto[]? status;
            try
            {
                status = await response.Content.ReadFromJsonAsync<WaveformStatusDto[]>(ct);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to deserialize waveform status from Content API response");
                return ResultContainer<WaveformStatusDto[]>.CreateFailResult("Content API returned an unexpected response.");
            }

            if (status is null)
            {
                _logger.LogError("Content API returned a null waveform status list");
                return ResultContainer<WaveformStatusDto[]>.CreateFailResult("Content API returned an empty response.");
            }

            return ResultContainer<WaveformStatusDto[]>.CreatePassResult(status);
        }
    }

    public async Task<Result> GenerateWaveformProfileAsync(string entryKey, CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);

        HttpResponseMessage response;
        try
        {
            response = await client.PostAsync($"api/track/{Uri.EscapeDataString(entryKey)}/waveform", null, ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for waveform generation of {EntryKey}", entryKey);
            return Result.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (response.IsSuccessStatusCode)
            {
                return Result.CreatePassResult();
            }

            if (response.StatusCode == HttpStatusCode.NotFound)
            {
                return Result.CreateFailResult("Track audio not found.");
            }

            var body = await response.Content.ReadAsStringAsync(ct);
            _logger.LogError("Content API waveform generation failed for {EntryKey}: {Status} {Body}", entryKey, (int)response.StatusCode, body);
            return Result.CreateFailResult("Failed to generate waveform profile.");
        }
    }

    public async Task<ResultContainer<List<ReleaseDto>>> GetReleasesAsync(CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);

        HttpResponseMessage response;
        try
        {
            response = await client.GetAsync("api/track/albums", ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for releases");
            return ResultContainer<List<ReleaseDto>>.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (!response.IsSuccessStatusCode)
            {
                _logger.LogError("Content API releases failed: {Status}", (int)response.StatusCode);
                return ResultContainer<List<ReleaseDto>>.CreateFailResult("Failed to load albums.");
            }

            List<ReleaseDto>? releases;
            try
            {
                releases = await response.Content.ReadFromJsonAsync<List<ReleaseDto>>(ct);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to deserialize releases from Content API response");
                return ResultContainer<List<ReleaseDto>>.CreateFailResult("Content API returned an unexpected response.");
            }

            if (releases is null)
            {
                _logger.LogError("Content API returned a null releases list");
                return ResultContainer<List<ReleaseDto>>.CreateFailResult("Content API returned an empty response.");
            }

            return ResultContainer<List<ReleaseDto>>.CreatePassResult(releases);
        }
    }

    public async Task<ResultContainer<List<GenreSummaryDto>>> GetGenreSummariesAsync(CancellationToken ct = default)
    {
        var client = _httpClientFactory.CreateClient(ContentCmsClientName);

        HttpResponseMessage response;
        try
        {
            response = await client.GetAsync("api/track/genres", ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Content API call failed for genre summaries");
            return ResultContainer<List<GenreSummaryDto>>.CreateFailResult("Content API is unreachable.");
        }

        using (response)
        {
            if (!response.IsSuccessStatusCode)
            {
                _logger.LogError("Content API genre summaries failed: {Status}", (int)response.StatusCode);
                return ResultContainer<List<GenreSummaryDto>>.CreateFailResult("Failed to load genres.");
            }

            List<GenreSummaryDto>? genres;
            try
            {
                genres = await response.Content.ReadFromJsonAsync<List<GenreSummaryDto>>(ct);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to deserialize genre summaries from Content API response");
                return ResultContainer<List<GenreSummaryDto>>.CreateFailResult("Content API returned an unexpected response.");
            }

            if (genres is null)
            {
                _logger.LogError("Content API returned a null genre summaries list");
                return ResultContainer<List<GenreSummaryDto>>.CreateFailResult("Content API returned an empty response.");
            }

            return ResultContainer<List<GenreSummaryDto>>.CreatePassResult(genres);
        }
    }

    public async Task<ResultContainer<int>> GetTrackCountAsync(CancellationToken ct = default)
    {
        // Re-use the paged endpoint: a single-item page carries the full TotalCount, so no
        // dedicated count endpoint is needed.
        var paged = await GetPagedAsync(page: 1, pageSize: 1, sortColumn: null, sortDescending: false, ct: ct);
        if (!paged.Success || paged.Value is null)
        {
            var error = paged.Messages.FirstOrDefault()?.Message ?? "Failed to load track count.";
            return ResultContainer<int>.CreateFailResult(error);
        }

        return ResultContainer<int>.CreatePassResult(paged.Value.TotalCount);
    }
}
