releases/VideoDownloader.Mobile/ApiClient.cs

using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json;

namespace VideoDownloader.Mobile;

/// <summary>데스크톱 원격 서버 API 클라이언트(M1). 토큰은 QR(#t=)/수동 입력에서 획득.</summary>
public sealed class ApiClient
{
    public static readonly ApiClient Instance = new();

    private readonly HttpClient _http = new() { Timeout = TimeSpan.FromSeconds(8) };

    public string? BaseUrl { get; private set; }
    public string? Token { get; private set; }
    public string? LastError { get; private set; }
    public bool IsConfigured => BaseUrl is { Length: > 0 } && Token is { Length: > 0 };

    public event Action? ConnectionChanged;

    /// <summary>QR 문자열(http://ip:port/#t=TOKEN) 또는 수동 입력(host:port + token) 구성.</summary>
    public bool Configure(string? qrOrUrl, string? manualToken = null)
    {
        try
        {
            if (!string.IsNullOrWhiteSpace(manualToken))
            {
                var host = qrOrUrl!.Trim().TrimEnd('/');
                if (!host.StartsWith("http", StringComparison.OrdinalIgnoreCase)) host = "http://" + host;
                BaseUrl = host;
                Token = manualToken.Trim();
            }
            else
            {
                var u = new Uri(qrOrUrl!.Trim());
                var frag = u.Fragment.TrimStart('#');
                var token = System.Web.HttpUtility.ParseQueryString(frag)["t"];
                if (string.IsNullOrEmpty(token)) return false;
                BaseUrl = $"http://{u.Authority}";
                Token = token;
            }
            _http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token);
            Preferences.Set("vd_base", BaseUrl);
            Preferences.Set("vd_token", Token);
            ConnectionChanged?.Invoke();
            return true;
        }
        catch { return false; }
    }

    public void Restore()
    {
        var b = Preferences.Get("vd_base", "");
        var t = Preferences.Get("vd_token", "");
        if (b.Length > 0 && t.Length > 0)
        {
            BaseUrl = b;
            Token = t;
            _http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", t);
        }
    }

    public void Forget()
    {
        BaseUrl = null; Token = null;
        Preferences.Remove("vd_base"); Preferences.Remove("vd_token");
        ConnectionChanged?.Invoke();
    }

    public async Task<List<QueueItem>> GetQueueAsync()
    {
        try
        {
            LastError = null;
            var r = await _http.GetAsync($"{BaseUrl}/api/queue");
            if (!r.IsSuccessStatusCode) { LastError = $"HTTP {(int)r.StatusCode}"; return new(); }
            return await r.Content.ReadFromJsonAsync<List<QueueItem>>() ?? new();
        }
        catch (Exception e) { LastError = e.Message; return new(); }
    }

    public async Task<bool> AddAsync(string url)
    {
        try
        {
            var r = await _http.PostAsJsonAsync($"{BaseUrl}/api/queue", new { url });
            return r.IsSuccessStatusCode;
        }
        catch { return false; }
    }

    public Task<bool> ControlAsync(string id, string action) =>
        PostAsync($"/api/queue/{id}/{action}");

    public async Task<bool> PairAsync()
    {
        try
        {
            var r = await _http.PostAsJsonAsync($"{BaseUrl}/api/pair", new { token = Token, device = "Android" });
            return r.IsSuccessStatusCode;
        }
        catch { return false; }
    }

    public async Task<List<LibraryItem>> GetLibraryAsync()
    {
        try
        {
            var r = await _http.GetAsync($"{BaseUrl}/api/library");
            if (!r.IsSuccessStatusCode) return new();
            return await r.Content.ReadFromJsonAsync<List<LibraryItem>>() ?? new();
        }
        catch { return new(); }
    }

    public string StreamUrl(LibraryItem item) => $"{BaseUrl}/stream/{item.Id}?t={Token}";
    public string FileUrl(LibraryItem item) => $"{BaseUrl}/file/{item.Id}?t={Token}";

    /// <summary>이어보기 위치 조회(U3). 실패/미저장 시 0.</summary>
    public async Task<double> GetPositionAsync(string id)
    {
        var dto = await GetAsync<PositionDto>($"/api/position/{id}");
        return dto?.PositionSec ?? 0;
    }

    /// <summary>이어보기 위치 저장(U3).</summary>
    public Task<bool> PostPositionAsync(string id, double positionSec) =>
        PostJsonAsync($"/api/position/{id}", new PositionDto(positionSec));

    /// <summary>라이브러리 항목을 폰에 저장(U4). 진행률 0~1, 취소 지원. 임시 .part 로 받아 완료 시 rename.</summary>
    public async Task DownloadFileAsync(LibraryItem item, string destPath, IProgress<double>? progress, CancellationToken ct)
    {
        Directory.CreateDirectory(Path.GetDirectoryName(destPath)!);
        var tmp = destPath + ".part";
        try
        {
            using var resp = await _http.GetAsync(FileUrl(item), HttpCompletionOption.ResponseHeadersRead, ct);
            resp.EnsureSuccessStatusCode();
            var total = resp.Content.Headers.ContentLength ?? item.SizeBytes;
            await using var src = await resp.Content.ReadAsStreamAsync(ct);
            await using var dst = File.Create(tmp);
            var buf = new byte[64 * 1024];
            long read = 0;
            int n;
            while ((n = await src.ReadAsync(buf, ct)) > 0)
            {
                await dst.WriteAsync(buf.AsMemory(0, n), ct);
                read += n;
                if (total > 0) progress?.Report((double)read / total);
            }
            File.Move(tmp, destPath, overwrite: true);
            progress?.Report(1);
        }
        finally
        {
            try { if (File.Exists(tmp)) File.Delete(tmp); } catch { }
        }
    }

    private async Task<bool> PostJsonAsync(string path, object body)
    {
        try
        {
            var r = await _http.PostAsJsonAsync($"{BaseUrl}{path}", body);
            return r.IsSuccessStatusCode;
        }
        catch { return false; }
    }

    private Task<bool> PostAsync(string path)
    {
        try { var t = _http.PostAsync($"{BaseUrl}{path}", null); return Continue(t); }
        catch { return Task.FromResult(false); }
        static async Task<bool> Continue(Task<HttpResponseMessage> t) { try { return (await t).IsSuccessStatusCode; } catch { return false; } }
    }

    private async Task<T?> GetAsync<T>(string path) where T : class
    {
        try
        {
            var r = await _http.GetAsync($"{BaseUrl}{path}");
            return r.IsSuccessStatusCode ? await r.Content.ReadFromJsonAsync<T>() : null;
        }
        catch { return null; }
    }
}

public sealed record QueueItem(string Id, string Title, string Url, string Status, double Percent);

public sealed record LibraryItem(string Id, string FileName, long SizeBytes, DateTime Modified);

public sealed record PositionDto(double PositionSec);