using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Edge;
using YuncangTrace.LocalService.Services.Hik;
namespace YuncangTrace.LocalService.Services;
/// 下载结果(HTTP 接口与桌面端共用)
/// 最终存放目录(`{录像根}/yyyy/MM/dd`)
/// 合并后的成片路径(单路时就是那一路的路径)
/// 各路段文件(合并失败时才有多个,且都已搬到用户目录)
/// 非致命问题(某路没下到等)
public sealed record PlaybackDownloadResult(
string Folder,
string? Merged,
IReadOnlyList Segments,
IReadOnlyList Warnings);
///
/// 按 NVR id 取登录凭据。
///
/// 桌面端走用户令牌调后端;后台扫码服务只有设备令牌,走云端下发或本地缓存。
/// 单独抽成委托,是为了让「按流计划下载」这件事不依赖登录态。
///
public delegate Task NvrCredentialProvider(int nvrId, CancellationToken ct);
///
/// 「按运单下载录像」的完整流程(**与界面无关**,桌面端和网页查件都走它)
///
/// 1. `pack-query` 拿到回放计划(扫码当时的工作台快照);
/// 2. 逐路下载到 **临时目录**(并发 2 路,8000 全速拉流优先、失败回落 RTSP);
/// 3. 多路按工作台画布布局**自动合并**成一个视频;
/// 4. 成片放到 `{录像根}/年/月/日/`,删掉临时片段。
///
/// 关键点:**录像存储路径是每台机器自己的设置**,跟"是不是设备服务器"无关 ——
/// 任何装了本机软件的电脑,查件后都能下载到自己配的目录里。
///
public sealed class PlaybackDownloadService
{
/// 同时下载几路(给 NVR 回放连接留余量)
private const int MaxParallel = 2;
private readonly OrderQueryService _query;
private readonly HikPlaybackService _playback;
private readonly Func _api;
private readonly Func _subjectId;
private readonly Func _token;
private readonly Func _root;
/// 选路:有设备管理服务就交给它,没有才本机下载(服务端自身为 null)
private readonly StreamGateway? _gateway;
public PlaybackDownloadService(
OrderQueryService query,
HikPlaybackService playback,
Func apiProvider,
Func subjectIdProvider,
Func tokenProvider,
Func videoRootProvider,
StreamGateway? gateway = null)
{
_query = query;
_playback = playback;
_api = apiProvider;
_subjectId = subjectIdProvider;
_token = tokenProvider;
_root = videoRootProvider;
_gateway = gateway;
}
///
/// 按运单号下载这段时间的录像(多路自动合并)
///
/// 查询失败 / 没有可下载的流(message 可直接给用户看)
public async Task DownloadAsync(string code, IProgress? progress = null,
CancellationToken ct = default)
{
var outcome = await _query.QueryAsync(code, ct).ConfigureAwait(false);
if (!outcome.Http.Ok || outcome.Query is null)
{
throw new InvalidOperationException(outcome.Http.Message);
}
var query = outcome.Query;
if (!query.Playback || query.Records.Count == 0)
{
throw new InvalidOperationException("这个运单没有可下载的回放(扫码时该通道没绑定工作台)");
}
var streams = query.Records.SelectMany(item => item.Streams).ToList();
if (streams.Count == 0)
{
throw new InvalidOperationException("工作台没有绑定摄像头,没有可下载的流");
}
var scanTime = query.Records[0].ScanTime.LocalDateTime;
var nvrs = streams
.Select(item => (Host: item.NvrHost, item.NvrPort))
.Where(item => !string.IsNullOrWhiteSpace(item.Host))
.Distinct()
.ToList();
// 选路(三级):
// ① 局域网有设备管理服务 → 交给它(共用它的 NVR 会话池)
// ② 没有 → 问云端,由能访问 NVR 的仓库设备代取、中转回来
// ③ 云端也不行 → 本机自己连 NVR(仓库内操作员的常规路径)
var peer = _gateway is null
? null
: await _gateway.FindAsync(nvrs, ct).ConfigureAwait(false);
if (peer is not null)
{
var viaEdge = await TryDownloadViaEdgeAsync(peer, code, streams, scanTime, progress, ct)
.ConfigureAwait(false);
if (viaEdge is not null) return viaEdge;
_gateway?.Invalidate();
progress?.Report("设备管理服务执行失败,改由云端中转…");
}
else
{
progress?.Report("局域网没有设备管理服务,改由云端中转…");
}
var viaCloud = await TryDownloadViaCloudAsync(code, scanTime, progress, ct).ConfigureAwait(false);
if (viaCloud is not null) return viaCloud;
progress?.Report("云端也不可用,改由本机直连录像机…");
return await DownloadByPlanAsync(
code,
streams,
scanTime,
_root(),
FetchCredentialAsync,
progress,
ct).ConfigureAwait(false);
}
///
/// 跨公司路径:云端建任务 → 仓库设备拉流并上传 → 本机把成片取回落盘。
///
/// 返回 null 表示「云端不可用/没有在线设备」,调用方降级到本机直连。
///
private async Task TryDownloadViaCloudAsync(string code, DateTime scanTime,
IProgress? progress, CancellationToken ct)
{
var api = _api?.Invoke();
var token = _token?.Invoke();
var subjectId = _subjectId?.Invoke() ?? 0;
if (api is null || string.IsNullOrWhiteSpace(token) || subjectId <= 0) return null;
string state;
string? taskId;
string? message;
try
{
(state, taskId, message) = await api.EdgeDownloadCreateAsync(token!, subjectId, code, ct)
.ConfigureAwait(false);
}
catch (Exception ex)
{
progress?.Report($"云端建任务失败:{ex.Message}");
return null;
}
if (state != "ok" || string.IsNullOrEmpty(taskId))
{
progress?.Report($"云端无法代取:{message ?? state}");
return null;
}
progress?.Report("仓库设备正在拉流并上传…");
var deadline = DateTime.UtcNow.AddMinutes(15);
var lastState = "";
while (DateTime.UtcNow < deadline)
{
ct.ThrowIfCancellationRequested();
var status = await api.EdgeDownloadStatusAsync(token!, subjectId, taskId, ct).ConfigureAwait(false);
if (status is null) return null;
if (status.State == "failed")
{
throw new InvalidOperationException(status.Error ?? "云端下载失败");
}
if (status.State == "done") break;
if (status.State != lastState)
{
lastState = status.State;
progress?.Report(status.State == "uploading"
? $"正在上传成片({status.Size / 1024.0 / 1024.0:0.0} MB)…"
: "等待仓库设备开始下载…");
}
await Task.Delay(TimeSpan.FromSeconds(1), ct).ConfigureAwait(false);
}
if (lastState != "" && lastState != "done" && DateTime.UtcNow >= deadline)
{
throw new InvalidOperationException("等待云端下载超时(15 分钟)");
}
var folder = VideoStorage.FolderFor(_root(), scanTime);
Directory.CreateDirectory(folder);
var target = Path.Combine(folder, $"{Sanitize(code)}_云端_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
progress?.Report("正在从云端取回成片…");
var size = await api.DownloadEdgeFileAsync(token!, subjectId, taskId!, target, ct).ConfigureAwait(false);
progress?.Report($"已保存:{target}({size / 1024.0 / 1024.0:0.0} MB)");
return new PlaybackDownloadResult(folder, target, new[] { target }, new List());
}
///
/// 交给设备管理服务:派任务 → 轮询 → 把成片拉回本机。
///
/// 返回 null 表示「没接单/没完成」,调用方降级到本机直连(保持原有失败语义)。
///
private async Task TryDownloadViaEdgeAsync(
EdgePeer peer,
string code,
IReadOnlyList streams,
DateTime scanTime,
IProgress? progress,
CancellationToken ct)
{
progress?.Report($"交由设备管理服务 {peer.Display} 执行…");
// 凭据仍从后端取:取流服务那边只有设备令牌,拿不到用户态凭据
var credentials = new List();
var seen = new HashSet();
foreach (var stream in streams)
{
if (!seen.Add(stream.NvrId)) continue;
credentials.Add(await FetchCredentialAsync(stream.NvrId, ct).ConfigureAwait(false));
}
using var client = new EdgeClient(peer);
var taskId = await client.CreateDownloadAsync(code, streams, credentials, scanTime, ct)
.ConfigureAwait(false);
if (string.IsNullOrEmpty(taskId))
{
progress?.Report("取流服务拒绝了下载任务");
return null;
}
progress?.Report("取流服务已接单,等待下载与合并…");
var completed = false;
var deadline = DateTime.UtcNow.AddMinutes(15);
while (DateTime.UtcNow < deadline)
{
ct.ThrowIfCancellationRequested();
var status = await client.GetStatusAsync(taskId, ct).ConfigureAwait(false);
if (status is null)
{
progress?.Report("取流服务状态查询失败");
return null;
}
if (status.IsFailed) throw new InvalidOperationException(status.Error ?? "取流服务下载失败");
if (status.IsDone)
{
completed = true;
break;
}
if (!string.IsNullOrEmpty(status.Progress)) progress?.Report(status.Progress);
await Task.Delay(TimeSpan.FromSeconds(2), ct).ConfigureAwait(false);
}
if (!completed) throw new InvalidOperationException("等待取流服务超时(15 分钟)");
var folder = VideoStorage.FolderFor(_root(), scanTime);
Directory.CreateDirectory(folder);
var target = Path.Combine(folder, $"{Sanitize(code)}_取流_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
progress?.Report("正在接收成片…");
var size = await client.DownloadFileAsync(taskId, target, ct).ConfigureAwait(false);
progress?.Report($"已保存:{target}({size / 1024.0 / 1024.0:0.0} MB)");
return new PlaybackDownloadResult(folder, target, new[] { target }, new List());
}
///
/// 按**流计划**下载并合并(不查库、不依赖用户令牌)
///
/// 桌面端由 查好计划再调进来;
/// 后台扫码服务只有设备令牌、调不了 `pack-query`,所以直接调这个。
///
/// 成片根目录(桌面端用用户设置,服务端用 ProgramData 下的录像目录)
/// 按 NVR id 取凭据(桌面端走 API,服务端走云端下发或本地缓存)
public async Task DownloadByPlanAsync(
string code,
IReadOnlyList streams,
DateTime scanTime,
string rootDir,
NvrCredentialProvider credentialProvider,
IProgress? progress = null,
CancellationToken ct = default)
{
if (streams.Count == 0) throw new InvalidOperationException("没有可下载的流");
var folder = VideoStorage.FolderFor(rootDir, scanTime);
Directory.CreateDirectory(folder);
var stamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
var workDir = Path.Combine(Path.GetTempPath(), "YuncangTrace", "playback",
$"{Sanitize(code)}_{stamp}");
Directory.CreateDirectory(workDir);
var warnings = new List();
var saved = new PlaybackClip?[streams.Count];
var gate = new SemaphoreSlim(MaxParallel);
var credentials = new Dictionary();
var credentialGate = new SemaphoreSlim(1, 1);
try
{
var tasks = new List();
for (var i = 0; i < streams.Count; i++)
{
var slot = i;
var stream = streams[i];
tasks.Add(Task.Run(async () =>
{
await gate.WaitAsync(ct).ConfigureAwait(false);
try
{
progress?.Report($"[{slot + 1}/{streams.Count}] {stream.DisplayName} 连接中…");
var credential = await CredentialAsync(stream.NvrId, credentials, credentialGate,
credentialProvider, ct).ConfigureAwait(false);
var name = $"{Sanitize(code)}_{stream.CameraId}_{Sanitize(stream.CameraName)}"
+ $"_{stream.StartTime.ToLocalTime():yyyyMMdd_HHmmss}.mp4";
var path = Path.Combine(workDir, name);
var file = await _playback.DownloadAsync(credential.Host, credential.Port,
credential.Username, credential.Password, stream.ChannelNo,
stream.StartTime, stream.EndTime, path,
new Progress(p =>
progress?.Report($"[{slot + 1}/{streams.Count}] {stream.DisplayName} {p.Message}")),
ct).ConfigureAwait(false);
saved[slot] = file;
progress?.Report($"[{slot + 1}/{streams.Count}] {stream.DisplayName} ✓ 完成");
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
warnings.Add($"{stream.DisplayName}:{ex.Message}");
progress?.Report($"[{slot + 1}/{streams.Count}] {stream.DisplayName} ✗ {ex.Message}");
}
finally
{
gate.Release();
}
}, ct));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
var parts = new List<(PackStream Stream, PlaybackClip Clip)>();
for (var i = 0; i < streams.Count; i++)
{
if (saved[i] is { } clip) parts.Add((streams[i], clip));
}
if (parts.Count == 0)
{
throw new InvalidOperationException(
"所有通道都没能下载成功:" + string.Join(";", warnings));
}
if (parts.Count == 1)
{
var single = parts[0].Clip.Path;
var target = Path.Combine(folder, Path.GetFileName(single));
if (File.Exists(target)) File.Delete(target);
File.Move(single, target);
progress?.Report($"已保存:{target}");
return new PlaybackDownloadResult(folder, target, new[] { target }, warnings);
}
var merged = Path.Combine(folder,
$"{Sanitize(code)}_合并_{parts[0].Stream.StartTime.ToLocalTime():yyyyMMdd_HHmmss}.mp4");
progress?.Report("正在按工作台布局合并…");
try
{
await _playback.ComposeAsync(
parts.Select(item => item.Clip.Path).ToList(),
parts.Select(item => item.Stream).ToList(),
merged,
parts.Select(item => item.Clip.StartOffset).ToList(),
new Progress(p => progress?.Report(p.Message)),
ct).ConfigureAwait(false);
progress?.Report($"已合并:{merged}");
return new PlaybackDownloadResult(folder, merged, new[] { merged }, warnings);
}
catch (Exception ex)
{
// 合并失败不丢数据:把各路段搬到用户目录
warnings.Add($"合并失败:{ex.Message}");
var moved = new List();
foreach (var (_, clip) in parts)
{
var target = Path.Combine(folder, Path.GetFileName(clip.Path));
if (File.Exists(target)) File.Delete(target);
File.Move(clip.Path, target);
moved.Add(target);
}
return new PlaybackDownloadResult(folder, null, moved, warnings);
}
}
finally
{
TryDeleteDirectory(workDir);
}
}
/// 按 NVR id 取凭据并缓存(同一份计划里每个 NVR 只取一次)
private async Task CredentialAsync(int nvrId, Dictionary cache,
SemaphoreSlim gate, NvrCredentialProvider provider, CancellationToken ct)
{
await gate.WaitAsync(ct).ConfigureAwait(false);
try
{
if (cache.TryGetValue(nvrId, out var cached)) return cached;
var credential = await provider(nvrId, ct).ConfigureAwait(false);
if (string.IsNullOrEmpty(credential.Password))
{
throw new InvalidOperationException(
$"录像机「{credential.Name}」没有保存密码,请到网页端「录像机」页补填");
}
cache[nvrId] = credential;
return credential;
}
finally
{
gate.Release();
}
}
/// 桌面端默认实现:带用户令牌调后端拿凭据
private async Task FetchCredentialAsync(int nvrId, CancellationToken ct)
{
var api = _api() ?? throw new InvalidOperationException("本机软件未登录");
var token = _token() ?? throw new InvalidOperationException("本机软件未登录");
return await api.NvrCredentialAsync(token, _subjectId(), nvrId, ct).ConfigureAwait(false);
}
private static string Sanitize(string? text)
{
if (string.IsNullOrEmpty(text)) return "_";
var invalid = Path.GetInvalidFileNameChars();
return new string(text.Select(ch => invalid.Contains(ch) ? '_' : ch).ToArray());
}
private static void TryDeleteDirectory(string dir)
{
try
{
if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
}
catch (Exception ex)
{
AppLog.Write($"[playback] 清理临时目录失败({dir}):{ex.Message}");
}
}
}