package service

import (
	"bytes"
	"context"
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"path/filepath"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/truewhile/MeBox/internal/model"
	"github.com/truewhile/MeBox/internal/service/cloud"
)

// overrideDanmakuOfficialBase points the "official" endpoint (match + fallback)
// at a local server for the duration of a test.
func overrideDanmakuOfficialBase(t *testing.T, base string) {
	t.Helper()
	old := danmakuOfficialBase
	danmakuOfficialBase = base
	t.Cleanup(func() { danmakuOfficialBase = old })
}

// writeDanmakuTestVideo writes a deterministic <16MB video-ish file and
// returns its path and the expected dandanplay hash (MD5 of the whole file,
// since the file is smaller than the 16MB prefix).
func writeDanmakuTestVideo(t *testing.T, name string) (path, wantHash string) {
	t.Helper()
	content := bytes.Repeat([]byte("MeBox-danmaku-hash-test-0123456789"), 500)
	path = filepath.Join(t.TempDir(), name)
	require.NoError(t, os.WriteFile(path, content, 0o644))
	sum := md5.Sum(content)
	return path, hex.EncodeToString(sum[:])
}

// danmakuOfficialServer serves /api/v2/match (with the given payload) and a
// comment library for the matched episode.
func danmakuOfficialServer(t *testing.T, matchBody, commentBody string, seen *string) *httptest.Server {
	t.Helper()
	mux := http.NewServeMux()
	mux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		b, _ := io.ReadAll(r.Body)
		if seen != nil {
			*seen = string(b)
		}
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, matchBody)
	})
	mux.HandleFunc("/api/v2/comment/25484", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, commentBody)
	})
	srv := httptest.NewServer(mux)
	t.Cleanup(srv.Close)
	return srv
}

// seedDanmakuVideoMedia inserts a media row with a real path (for the hash
// layer) and optional episode number.
func seedDanmakuVideoMedia(t *testing.T, svc *DanmakuService, id, title, path string, size int64, episode int) {
	t.Helper()
	m := model.Media{Title: title, Path: path, SizeBytes: size, EpisodeNum: episode}
	m.ID = id
	require.NoError(t, svc.repo.DB.Create(&m).Error)
}

// 第 1 层：本地文件直接算 hash → 官方 /api/v2/match → 命中后拉弹幕。
func TestDanmakuFetchHashMatchLayer(t *testing.T) {
	videoPath, wantHash := writeDanmakuTestVideo(t, "测试动画.第01话.mkv")
	var seen string
	official := danmakuOfficialServer(t,
		`{"success":true,"isMatched":true,"matches":[{"episodeId":25484,"animeId":1001,"animeTitle":"测试动画","episodeTitle":"第1话"}]}`,
		`<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">弹幕Hash命中</d></i>`,
		&seen)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	seedDanmakuVideoMedia(t, svc, "mH", "测试动画", videoPath, 32000, 1)

	res, err := svc.Fetch(ctx, "mH", "", "")
	require.NoError(t, err)
	require.True(t, res.Enabled)
	require.Equal(t, "xml", res.SourceType)
	require.Contains(t, res.Raw, "弹幕Hash命中")
	require.Empty(t, res.Candidates)
	require.Equal(t, "测试动画", res.AnimeTitle)
	require.Equal(t, "第1话", res.EpisodeTitle)
	require.Equal(t, int64(25484), res.EpisodeID)
	require.Equal(t, "hash", res.MatchMode)

	// match 请求体：文件名去扩展名并 URL 转义（官方接口要求，实测验证）、
	// hash、大小、matchMode 齐全。
	require.Contains(t, seen, `"fileName":"`+url.QueryEscape("测试动画.第01话")+`"`)
	require.Contains(t, seen, `"fileHash":"`+wantHash+`"`)
	require.Contains(t, seen, `"fileSize":32000`)
	require.Contains(t, seen, `"matchMode":"hashAndFileName"`)
}

// 第 1 层拉弹幕：官方 match 给出的 episodeId 属于官方 ID 空间，不能直接拿去
// 请求第三方源（真实源上只会 404）。必须用官方给到的剧名+集数在配置源里重定位
// 到配置源自己的 episodeId，再用它拉弹幕。
func TestDanmakuFetchHashMatchRemapsEpisodeIDToConfiguredSource(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "测试动画.第01话.mkv")

	// 配置源使用自己的 ID 空间：官方是 90001，配置源是 25484。
	// 副标题一致，用于跨源确认是同一集。
	const subtitle = "测试副标题"
	cfgMux := http.NewServeMux()
	cfgMux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"hasMore":false,"animes":[{"animeId":1001,"animeTitle":"测试动画","episodes":[{"episodeId":25484,"episodeTitle":"第1话 `+subtitle+`"}]}]}`)
	})
	cfgMux.HandleFunc("/api/v2/comment/25484", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">弹幕A</d></i>`)
	})
	cfgSrv := httptest.NewServer(cfgMux)
	t.Cleanup(cfgSrv.Close)

	officialMux := http.NewServeMux()
	officialMux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"success":true,"isMatched":true,"matches":[{"episodeId":90001,"animeId":1001,"animeTitle":"测试动画","episodeTitle":"第1话 `+subtitle+`"}]}`)
	})
	officialMux.HandleFunc("/api/v2/comment/90001", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">弹幕B官方</d></i>`)
	})
	official := httptest.NewServer(officialMux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL))
	seedDanmakuVideoMedia(t, svc, "mC", "测试动画", videoPath, 32000, 0)

	res, err := svc.Fetch(ctx, "mC", "", "")
	require.NoError(t, err)
	// 弹幕取自配置源，且用的是重定位后的 ID。
	require.Contains(t, res.Raw, "弹幕A")
	require.NotContains(t, res.Raw, "弹幕B官方")
	require.Equal(t, int64(25484), res.EpisodeID)
	require.Equal(t, "hash", res.MatchMode)
}

// 配置源能定位到该集，但返回的是空弹幕库（count=0）时必须回官方兜底：
// 第三方目录里有条目不代表真的收录了弹幕。
func TestDanmakuFetchHashMatchFallsBackWhenConfiguredLibraryIsEmpty(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "测试动画.第01话.mkv")

	const subtitle = "测试副标题"
	cfgMux := http.NewServeMux()
	cfgMux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"hasMore":false,"animes":[{"animeId":1001,"animeTitle":"测试动画","episodes":[{"episodeId":25484,"episodeTitle":"第1话 `+subtitle+`"}]}]}`)
	})
	// 该集在配置源上存在，但弹幕为空。
	cfgMux.HandleFunc("/api/v2/comment/25484", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"count":0,"comments":[]}`)
	})
	cfgSrv := httptest.NewServer(cfgMux)
	t.Cleanup(cfgSrv.Close)

	officialMux := http.NewServeMux()
	officialMux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"success":true,"isMatched":true,"matches":[{"episodeId":90001,"animeId":1001,"animeTitle":"测试动画","episodeTitle":"第1话 `+subtitle+`"}]}`)
	})
	officialMux.HandleFunc("/api/v2/comment/90001", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">官方兜底弹幕</d></i>`)
	})
	official := httptest.NewServer(officialMux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL))
	seedDanmakuVideoMedia(t, svc, "mEmpty", "测试动画", videoPath, 32000, 0)

	res, err := svc.Fetch(ctx, "mEmpty", "", "")
	require.NoError(t, err)
	require.Contains(t, res.Raw, "官方兜底弹幕")
	require.Equal(t, int64(90001), res.EpisodeID)
}

// 同一集在配置源里命中多个来源时：自动加载第一条，其余作为可切换来源返回，
// 让用户能在面板里直接切换，而不必重新搜索。
func TestDanmakuFetchHashMatchReturnsAlternatives(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "多来源动画.第01话.mkv")

	const subtitle = "同一个副标题"
	cfgMux := http.NewServeMux()
	cfgMux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		// 三个来源都指向同一集（副标题与集数一致），模拟 LogVar 聚合多站。
		fmt.Fprint(w, `{"hasMore":false,"animes":[`+
			`{"animeId":1,"animeTitle":"多来源动画 from dandan","episodes":[{"episodeId":101,"episodeTitle":"第1话 `+subtitle+`"}]},`+
			`{"animeId":2,"animeTitle":"多来源动画 from bilibili","episodes":[{"episodeId":102,"episodeTitle":"第1话 `+subtitle+`"}]},`+
			`{"animeId":3,"animeTitle":"多来源动画 from qq","episodes":[{"episodeId":103,"episodeTitle":"第1话 `+subtitle+`"}]}]}`)
	})
	cfgMux.HandleFunc("/api/v2/comment/101", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">首选来源弹幕</d></i>`)
	})
	cfgSrv := httptest.NewServer(cfgMux)
	t.Cleanup(cfgSrv.Close)

	officialMux := http.NewServeMux()
	officialMux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"success":true,"isMatched":true,"matches":[{"episodeId":90001,"animeId":9,"animeTitle":"多来源动画","episodeTitle":"第1话 `+subtitle+`"}]}`)
	})
	officialMux.HandleFunc("/api/v2/comment/90001", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">官方弹幕</d></i>`)
	})
	official := httptest.NewServer(officialMux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL))
	seedDanmakuVideoMedia(t, svc, "mAlt", "多来源动画", videoPath, 32000, 0)

	res, err := svc.Fetch(ctx, "mAlt", "", "")
	require.NoError(t, err)

	// 自动加载第一个来源（沿用既有取值逻辑）。
	require.Contains(t, res.Raw, "首选来源弹幕")
	require.Equal(t, int64(101), res.EpisodeID)
	require.Equal(t, "hash", res.MatchMode)

	// 三个来源全部作为可切换列表返回。
	require.Len(t, res.Alternatives, 3)
	var ids []int64
	for _, a := range res.Alternatives {
		for _, e := range a.Episodes {
			ids = append(ids, e.EpisodeID)
		}
	}
	require.Equal(t, []int64{101, 102, 103}, ids)

	// Candidates 的语义必须保持不变（这里不是"必须选择"），否则前端会停止自动加载。
	require.Empty(t, res.Candidates)
}

// 只有一个来源时不应产生 alternatives，避免面板出现无意义的单条列表。
func TestDanmakuFetchHashMatchNoAlternativesForSingleSource(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "单来源动画.第01话.mkv")

	const subtitle = "唯一副标题"
	cfgMux := http.NewServeMux()
	cfgMux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"hasMore":false,"animes":[{"animeId":1,"animeTitle":"单来源动画","episodes":[{"episodeId":201,"episodeTitle":"第1话 `+subtitle+`"}]}]}`)
	})
	cfgMux.HandleFunc("/api/v2/comment/201", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">唯一来源弹幕</d></i>`)
	})
	cfgSrv := httptest.NewServer(cfgMux)
	t.Cleanup(cfgSrv.Close)

	officialMux := http.NewServeMux()
	officialMux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"success":true,"isMatched":true,"matches":[{"episodeId":90002,"animeId":9,"animeTitle":"单来源动画","episodeTitle":"第1话 `+subtitle+`"}]}`)
	})
	official := httptest.NewServer(officialMux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL))
	seedDanmakuVideoMedia(t, svc, "mOne", "单来源动画", videoPath, 32000, 0)

	res, err := svc.Fetch(ctx, "mOne", "", "")
	require.NoError(t, err)
	require.Contains(t, res.Raw, "唯一来源弹幕")
	require.Empty(t, res.Alternatives)
}

// 开启合并后：同一集的多个来源被合并，重复弹幕（时间+内容相同）只保留一条。
func TestDanmakuFetchMergeSourcesCombinesAndDeduplicates(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "合并动画.第01话.mkv")

	const subtitle = "同一副标题"
	cfgMux := http.NewServeMux()
	cfgMux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"hasMore":false,"animes":[`+
			`{"animeId":1,"animeTitle":"来源A","episodes":[{"episodeId":301,"episodeTitle":"第1话 `+subtitle+`"}]},`+
			`{"animeId":2,"animeTitle":"来源B","episodes":[{"episodeId":302,"episodeTitle":"第1话 `+subtitle+`"}]}]}`)
	})
	// A 与 B 各有一条重复弹幕（1.0 秒「重复弹幕」）和各自独有的一条。
	cfgMux.HandleFunc("/api/v2/comment/301", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"count":2,"comments":[`+
			`{"p":"1.00,1,16777215,u1","m":"重复弹幕"},`+
			`{"p":"2.00,1,16777215,u1","m":"只在A"}]}`)
	})
	cfgMux.HandleFunc("/api/v2/comment/302", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"count":2,"comments":[`+
			`{"p":"1.00,1,16777215,u2","m":"重复弹幕"},`+
			`{"p":"3.00,1,16777215,u2","m":"只在B"}]}`)
	})
	cfgSrv := httptest.NewServer(cfgMux)
	t.Cleanup(cfgSrv.Close)

	officialMux := http.NewServeMux()
	officialMux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"success":true,"isMatched":true,"matches":[{"episodeId":90003,"animeId":9,"animeTitle":"合并动画","episodeTitle":"第1话 `+subtitle+`"}]}`)
	})
	official := httptest.NewServer(officialMux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL))
	seedDanmakuVideoMedia(t, svc, "mMerge", "合并动画", videoPath, 32000, 0)

	res, err := svc.FetchWithOptions(ctx, "mMerge", "", "", DanmakuFetchOptions{MergeSources: true})
	require.NoError(t, err)
	require.Equal(t, 2, res.MergedSources, "expected both sources to be merged")

	merged := parseDanmakuComments(res.Raw)
	require.Len(t, merged, 3, "duplicate comment must collapse: got %#v", merged)
	require.Equal(t, "重复弹幕", merged[0].Text)
	require.Equal(t, 1.0, merged[0].TimeSec)
	require.Equal(t, "只在A", merged[1].Text)
	require.Equal(t, "只在B", merged[2].Text)
	// 合并结果用 JSON 输出，前端据此选择解析分支。
	require.Equal(t, "json", res.SourceType)
}

// 未开启合并时，行为与原来一致：只加载自动选中的那一个来源。
func TestDanmakuFetchWithoutMergeLoadsSingleSource(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "不合并动画.第01话.mkv")

	const subtitle = "同一副标题"
	cfgMux := http.NewServeMux()
	cfgMux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"hasMore":false,"animes":[`+
			`{"animeId":1,"animeTitle":"来源A","episodes":[{"episodeId":401,"episodeTitle":"第1话 `+subtitle+`"}]},`+
			`{"animeId":2,"animeTitle":"来源B","episodes":[{"episodeId":402,"episodeTitle":"第1话 `+subtitle+`"}]}]}`)
	})
	cfgMux.HandleFunc("/api/v2/comment/401", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"count":1,"comments":[{"p":"1.00,1,16777215,u1","m":"只在A"}]}`)
	})
	cfgMux.HandleFunc("/api/v2/comment/402", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"count":1,"comments":[{"p":"1.00,1,16777215,u2","m":"只在B"}]}`)
	})
	cfgSrv := httptest.NewServer(cfgMux)
	t.Cleanup(cfgSrv.Close)

	officialMux := http.NewServeMux()
	officialMux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"success":true,"isMatched":true,"matches":[{"episodeId":90004,"animeId":9,"animeTitle":"不合并动画","episodeTitle":"第1话 `+subtitle+`"}]}`)
	})
	official := httptest.NewServer(officialMux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL))
	seedDanmakuVideoMedia(t, svc, "mNoMerge", "不合并动画", videoPath, 32000, 0)

	res, err := svc.Fetch(ctx, "mNoMerge", "", "")
	require.NoError(t, err)
	require.Zero(t, res.MergedSources)
	require.Equal(t, int64(401), res.EpisodeID)
	// 只应有自动选中来源的弹幕。
	require.Contains(t, res.Raw, "只在A")
	require.NotContains(t, res.Raw, "只在B")
	// 两个来源仍然作为可切换项返回（合并开关不影响候选列表）。
	require.Len(t, res.Alternatives, 2)
}

// 合并偏好按用户持久化。
func TestDanmakuMergeSourcesPreferencePersistsPerUser(t *testing.T) {
	svc := newDanmakuTestService(t)
	ctx := context.Background()

	userA := model.User{Username: "merge-user-a", PasswordHash: "x", Role: "user", IsActive: true}
	userA.ID = "user-a"
	userB := model.User{Username: "merge-user-b", PasswordHash: "x", Role: "user", IsActive: true}
	userB.ID = "user-b"
	require.NoError(t, svc.repo.User.Create(ctx, &userA))
	require.NoError(t, svc.repo.User.Create(ctx, &userB))

	require.False(t, svc.MergeSourcesEnabled(ctx, "user-a"))
	require.NoError(t, svc.SetMergeSources(ctx, "user-a", true))
	require.True(t, svc.MergeSourcesEnabled(ctx, "user-a"))
	// 另一个用户不受影响。
	require.False(t, svc.MergeSourcesEnabled(ctx, "user-b"))

	// 重新读取确认已落库，且 ConfigForUser 会带出该偏好。
	cfg := svc.ConfigForUser(ctx, "user-a")
	require.True(t, cfg.MergeSources)
	require.False(t, svc.ConfigForUser(ctx, "user-b").MergeSources)
}

// 配置源搜不到对应剧集时必须回退官方：用官方自身的 episodeId 请求官方，
// 而不是拿官方 ID 去撞配置源。
func TestDanmakuFetchHashMatchFallsBackToOfficialWhenConfiguredHasNoMatch(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "冷门动画.第01话.mkv")

	cfgMux := http.NewServeMux()
	cfgMux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"hasMore":false,"animes":[]}`)
	})
	cfgSrv := httptest.NewServer(cfgMux)
	t.Cleanup(cfgSrv.Close)

	officialMux := http.NewServeMux()
	officialMux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"success":true,"isMatched":true,"matches":[{"episodeId":90001,"animeId":1001,"animeTitle":"冷门动画","episodeTitle":"第1话 无人知晓"}]}`)
	})
	officialMux.HandleFunc("/api/v2/comment/90001", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">弹幕来自官方</d></i>`)
	})
	official := httptest.NewServer(officialMux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL))
	seedDanmakuVideoMedia(t, svc, "mNoMatch", "冷门动画", videoPath, 32000, 0)

	res, err := svc.Fetch(ctx, "mNoMatch", "", "")
	require.NoError(t, err)
	require.Contains(t, res.Raw, "弹幕来自官方")
	require.Equal(t, int64(90001), res.EpisodeID)
}

func TestDanmakuFetchHashMatchConfiguredFailsFallsBackOfficial(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "测试动画.第01话.mkv")

	// 配置源：搜索正常，但弹幕接口 500。
	mux := http.NewServeMux()
	mux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"hasMore":false,"animes":[{"animeId":1001,"animeTitle":"测试动画","episodes":[{"episodeId":25484,"episodeTitle":"第1话"}]}]}`)
	})
	mux.HandleFunc("/api/v2/comment/25484", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	})
	cfgSrv := httptest.NewServer(mux)
	t.Cleanup(cfgSrv.Close)

	official := danmakuOfficialServer(t,
		`{"success":true,"isMatched":true,"matches":[{"episodeId":25484,"animeId":1001,"animeTitle":"测试动画"}]}`,
		`<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">弹幕官方兜底</d></i>`,
		nil)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL))
	seedDanmakuVideoMedia(t, svc, "mF", "测试动画", videoPath, 32000, 0)

	res, err := svc.Fetch(ctx, "mF", "", "")
	require.NoError(t, err)
	require.Contains(t, res.Raw, "弹幕官方兜底")
}

// 第 1 层未命中时，即使官方附带模糊候选，也不能把第一条当作精准匹配；
// 应继续走第 2 层按文件名+集数搜索。
func TestDanmakuFetchHashMissFallsBackToFileNameSearch(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "测试动画.第01话.mkv")

	cfgSrv := newDanmakuSourceServer(t) // 搜索 + 弹幕A
	official := danmakuOfficialServer(t,
		`{"success":true,"isMatched":false,"matches":[{"episodeId":120140001,"animeId":12014,"animeTitle":"91天","episodeTitle":"第1话 杀人之夜"}]}`,
		`<i></i>`, nil)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL()))
	seedDanmakuVideoMedia(t, svc, "mM", "刮削标题", videoPath, 32000, 1)

	res, err := svc.Fetch(ctx, "mM", "", "")
	require.NoError(t, err)
	require.True(t, res.Enabled)
	require.Contains(t, res.Raw, "弹幕A")
	require.Equal(t, "filename", res.MatchMode)
	require.Equal(t, "测试动画", res.AnimeTitle)
	// 第 2 层命中：搜索请求按文件名进行，而不是误用官方第一条模糊候选。
	query, err := url.ParseQuery(cfgSrv.lastSearch)
	require.NoError(t, err)
	require.Contains(t, query.Get("anime"), "测试动画.第01话")
	require.NotContains(t, query.Get("anime"), "91天")
}

// hash 未精确命中时，若本地已有刮削的剧名、年份、集数和集标题，应先用这些
// 元数据锁定正确来源，而不是直接进入大量候选的手工选择。
func TestDanmakuFetchHashMissUsesScrapedMetadata(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "local-release-name.mkv")
	cfgSrv := newDanmakuSourceServerWithSearch(t,
		`{"hasMore":false,"animes":[`+
			`{"animeId":1,"animeTitle":"命运石之门 0(2018)【TV动画】from dandan&animeko","episodes":[{"episodeId":120140001,"episodeTitle":"【dandan&animeko】 第1话 零化域的缺失之环-Absolute Zero-"}]},`+
			`{"animeId":2,"animeTitle":"命运石之门(2011)【TV动画】from dandan&animeko","episodes":[{"episodeId":25484,"episodeTitle":"【dandan&animeko】 第1话 始与终的序章-Turning Point-"}]},`+
			`{"animeId":3,"animeTitle":"命运石之门(2011)【动漫】from 360","episodes":[{"episodeId":120140002,"episodeTitle":"【qq】 第1集"}]}`+
			`]}`)
	official := danmakuOfficialServer(t,
		`{"success":true,"isMatched":false,"matches":[{"episodeId":120140001,"animeId":12014,"animeTitle":"91天","episodeTitle":"第1话 杀人之夜"}]}`,
		`<i></i>`, nil)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, cfgSrv.URL()))
	media := model.Media{
		Title:        "命运石之门",
		Year:         2011,
		EpisodeNum:   1,
		EpisodeTitle: "起始与终结的序章",
		Path:         videoPath,
		SizeBytes:    32000,
		ScrapeStatus: "matched",
	}
	media.ID = "mScrapedMeta"
	require.NoError(t, svc.repo.DB.Create(&media).Error)

	res, err := svc.Fetch(ctx, media.ID, "", "")
	require.NoError(t, err)
	require.True(t, res.Enabled)
	require.Contains(t, res.Raw, "弹幕A")
	require.Equal(t, "metadata", res.MatchMode)
	require.Equal(t, "命运石之门(2011)【TV动画】from dandan&animeko", res.AnimeTitle)
	require.Equal(t, int64(25484), res.EpisodeID)
	require.Empty(t, res.Candidates)
}

// strm：通过解析出的直链 Range 拉 16MB 前缀算 hash → match → 拉弹幕。
// range server 模拟 115 CDN 防盗链：UA 不匹配直接 403（真实部署中
// 直链绑定换取时的 UA，不带绑定 UA 拉取会失败，见 pan115_openapi.go）。
func TestDanmakuFetchStrmHashViaDirectLink(t *testing.T) {
	content := bytes.Repeat([]byte("strm-video-bytes-0123456789"), 400)
	sum := md5.Sum(content)
	wantHash := hex.EncodeToString(sum[:])

	var gotRange, gotUA string
	rangeSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gotRange = r.Header.Get("Range")
		gotUA = r.Header.Get("User-Agent")
		if gotUA != "bound-ua-115" {
			w.WriteHeader(http.StatusForbidden)
			return
		}
		w.Header().Set("Content-Type", "application/octet-stream")
		_, _ = w.Write(content)
	}))
	t.Cleanup(rangeSrv.Close)

	var seen string
	official := danmakuOfficialServer(t,
		`{"success":true,"isMatched":true,"matches":[{"episodeId":25484,"animeId":1001,"animeTitle":"远程动画"}]}`,
		`<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">弹幕Strm命中</d></i>`,
		&seen)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	var gotProvider string
	svc.SetStrmResolver(func(_ context.Context, provider string, _ url.Values) (*StrmPlayResult, error) {
		gotProvider = provider
		// 播放链路 302 直链 + 绑定的 UA 头（防服务端直连 403）。
		return &StrmPlayResult{
			RedirectURL: rangeSrv.URL,
			Link:        &cloud.DirectLink{URL: rangeSrv.URL, Headers: map[string]string{"User-Agent": "bound-ua-115"}},
		}, nil
	})
	ctx := context.Background()
	strmPath := filepath.Join(t.TempDir(), "远程动画.第01话.strm")
	require.NoError(t, os.WriteFile(strmPath, []byte("http://example.invalid/api/strm/play/115/video.mkv?acct=1&pickcode=abc\n"), 0o644))
	seedDanmakuVideoMedia(t, svc, "mS", "远程动画", strmPath, 64, 0)
	// STRMURL 需要显式写回（扫库时才解析）。
	var media model.Media
	require.NoError(t, svc.repo.DB.First(&media, "id = ?", "mS").Error)
	media.STRMURL = "/api/strm/play/115/video.mkv?acct=1&pickcode=abc"
	require.NoError(t, svc.repo.DB.Save(&media).Error)

	res, err := svc.Fetch(ctx, "mS", "", "")
	require.NoError(t, err)
	require.True(t, res.Enabled)
	require.Contains(t, res.Raw, "弹幕Strm命中")
	require.Equal(t, "115", gotProvider)
	require.Contains(t, gotRange, "bytes=0-")
	require.Equal(t, "bound-ua-115", gotUA) // 防盗链 UA 必须透传
	require.Contains(t, seen, `"fileHash":"`+wantHash+`"`)
	require.Contains(t, seen, `"fileName":"`+url.QueryEscape("远程动画.第01话")+`"`)
	// strm 的 SizeBytes 是文本大小，不参与 match。
	require.Contains(t, seen, `"fileSize":0`)
}

// match 接口 fileName 语义：去扩展名；strm 文件名含视频扩展名时剥两层。
func TestDanmakuMatchFileName(t *testing.T) {
	cases := []struct{ in, want string }{
		{"/lib/某番剧.第01话.mkv", "某番剧.第01话"},
		{"/lib/某番剧.第01话.strm", "某番剧.第01话"},
		{"/lib/movie.mkv.strm", "movie"},
		{"plain", "plain"},
	}
	for _, c := range cases {
		require.Equal(t, c.want, danmakuMatchFileName(c.in), "path=%s", c.in)
	}
}

// hashLocalFile：本地视频直接读盘算前 16MB MD5，且第二次走缓存。
func TestDanmakuHashLocalFile(t *testing.T) {
	videoPath, wantHash := writeDanmakuTestVideo(t, "hashme.mkv")
	svc := newDanmakuTestService(t)
	got, ok := svc.hashLocalFile(videoPath)
	require.True(t, ok)
	require.Equal(t, wantHash, got)
	got2, ok := svc.hashLocalFile(videoPath)
	require.True(t, ok)
	require.Equal(t, wantHash, got2)
	missing, ok := svc.hashLocalFile(filepath.Join(t.TempDir(), "nope.mkv"))
	require.False(t, ok)
	require.Empty(t, missing)
}

// 配置源与官方同源时，回退不重复请求同一台服务器（bases 只含一份）。
func TestDanmakuSameBase(t *testing.T) {
	require.True(t, sameDanmakuBase("https://api.dandanplay.net", "https://api.dandanplay.net"))
	require.False(t, sameDanmakuBase("https://api.dandanplay.net", "https://dm.example.com"))
	require.False(t, sameDanmakuBase("", "https://api.dandanplay.net"))
}

// fetchCommentWithFallback：配置源与官方同源时不重复请求；
// 全失败时带出最后一跳错误。
func TestDanmakuFetchCommentWithFallback(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	}))
	t.Cleanup(srv.Close)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	raw, st, err := svc.fetchCommentWithFallback(ctx, srv.URL, srv.URL, "25484")
	require.Error(t, err)
	require.Empty(t, raw)
	require.Equal(t, "auto", st)
}

// 视频即便能命中 Hash 自动识别，当用户传入手动搜索关键词时应跳过 Hash 匹配，走关键词搜索。
func TestDanmakuFetchHashMatchSkippedOnManualKeyword(t *testing.T) {
	videoPath, _ := writeDanmakuTestVideo(t, "测试动画.第01话.mkv")

	// 官方服务同时提供 match 和 search：
	// match 会返回 episodeId=25484（动画A）
	// search 会根据关键词返回 episodeId=99999（动画B）
	mux := http.NewServeMux()
	var matchCalled bool
	mux.HandleFunc("/api/v2/match", func(w http.ResponseWriter, r *http.Request) {
		matchCalled = true
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"success":true,"isMatched":true,"matches":[{"episodeId":25484,"animeId":1001,"animeTitle":"自动识别动画A","episodeTitle":"第1话"}]}`)
	})
	mux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"hasMore":false,"animes":[{"animeId":2002,"animeTitle":"手动搜索动画B","episodes":[{"episodeId":99999,"episodeTitle":"第1话"}]}]}`)
	})
	mux.HandleFunc("/api/v2/comment/25484", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">自动识别弹幕</d></i>`)
	})
	mux.HandleFunc("/api/v2/comment/99999", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.5,1,16777215,user2">手动搜索弹幕</d></i>`)
	})
	official := httptest.NewServer(mux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	seedDanmakuVideoMedia(t, svc, "mManual", "自动识别动画A", videoPath, 32000, 1)

	// 1) 默认自动识别：命中 Hash 识别
	resAuto, err := svc.Fetch(ctx, "mManual", "", "")
	require.NoError(t, err)
	require.True(t, matchCalled)
	require.Equal(t, "hash", resAuto.MatchMode)
	require.Equal(t, int64(25484), resAuto.EpisodeID)
	require.Contains(t, resAuto.Raw, "自动识别弹幕")

	// 2) 用户传入手动搜索关键词：跳过 Hash 识别，命中搜索结果动画B
	resManual, err := svc.Fetch(ctx, "mManual", "手动搜索动画B", "")
	require.NoError(t, err)
	require.Equal(t, "search", resManual.MatchMode)
	require.Equal(t, int64(99999), resManual.EpisodeID)
	require.Equal(t, "手动搜索动画B", resManual.AnimeTitle)
	require.Contains(t, resManual.Raw, "手动搜索弹幕")
}

// Emby 远程挂载条目：通过伪装 ID 解析出流直链，通过 Range 提取 16MB 前缀计算 hash 并匹配弹幕。
func TestDanmakuFetchEmbyRemoteHashViaDirectLink(t *testing.T) {
	content := bytes.Repeat([]byte("emby-remote-video-bytes-9876543210"), 300)
	sum := md5.Sum(content)
	wantHash := hex.EncodeToString(sum[:])

	var gotRange string
	var rangeHits int
	rangeSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		rangeHits++
		gotRange = r.Header.Get("Range")
		w.Header().Set("Content-Type", "application/octet-stream")
		_, _ = w.Write(content)
	}))
	t.Cleanup(rangeSrv.Close)

	var seen string
	official := danmakuOfficialServer(t,
		`{"success":true,"isMatched":true,"matches":[{"episodeId":25484,"animeId":2001,"animeTitle":"芙莉莲","episodeTitle":"第1话"}]}`,
		`<?xml version="1.0"?><i><d p="1.2,1,16777215,user1">Emby远程弹幕命中</d></i>`,
		&seen)
	overrideDanmakuOfficialBase(t, official.URL)

	remoteMediaID := EncodeEmbyRemoteID("mount-123", "remote-item-456")
	svc := newDanmakuTestService(t)
	svc.SetRemoteMediaResolver(func(_ context.Context, encodedID string) (*model.Media, string, error) {
		require.Equal(t, remoteMediaID, encodedID)
		return &model.Media{
			Base:         model.Base{ID: remoteMediaID},
			Title:        "葬送的芙莉莲",
			EpisodeTitle: "第1话",
			EpisodeNum:   1,
			Path:         "/mnt/emby/anime/Frieren/S01E01.mkv",
			SizeBytes:    int64(len(content)),
			DurationSec:  1400,
		}, rangeSrv.URL, nil
	})

	ctx := context.Background()
	res, err := svc.Fetch(ctx, remoteMediaID, "", "")
	require.NoError(t, err)
	require.True(t, res.Enabled)
	require.Equal(t, "hash", res.MatchMode)
	require.Equal(t, int64(25484), res.EpisodeID)
	require.Equal(t, "芙莉莲", res.AnimeTitle)
	require.Contains(t, res.Raw, "Emby远程弹幕命中")
	require.Contains(t, gotRange, "bytes=0-")
	require.Contains(t, seen, `"fileHash":"`+wantHash+`"`)
	require.Contains(t, seen, `"fileName":"`+url.QueryEscape("S01E01")+`"`)
	require.Equal(t, 1, rangeHits)

	// 第二次拉取验证 hashCache 命中，不重复请求 rangeSrv
	res2, err := svc.Fetch(ctx, remoteMediaID, "", "")
	require.NoError(t, err)
	require.Equal(t, "hash", res2.MatchMode)
	require.Equal(t, 1, rangeHits)
}

// Emby 远程直链拉取失败时（如网络异常），能平滑降级走番剧原名/标题关键词搜索。
func TestDanmakuFetchEmbyRemoteStreamFailedFallsBackToSearch(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/api/v2/search/episodes", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		// 文件名搜索 ep01 时无结果，模拟文件名未匹配
		if r.URL.Query().Get("anime") == "ep01" {
			fmt.Fprint(w, `{"hasMore":false,"animes":[]}`)
			return
		}
		// 降级到番剧名搜索命中
		fmt.Fprint(w, `{"hasMore":false,"animes":[{"animeId":3001,"animeTitle":"降级搜索番剧","episodes":[{"episodeId":7799,"episodeTitle":"第1话"}]}]}`)
	})
	mux.HandleFunc("/api/v2/comment/7799", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprint(w, `<?xml version="1.0"?><i><d p="0.8,1,16777215,user1">降级搜索弹幕</d></i>`)
	})
	official := httptest.NewServer(mux)
	t.Cleanup(official.Close)
	overrideDanmakuOfficialBase(t, official.URL)

	remoteMediaID := EncodeEmbyRemoteID("mount-123", "remote-item-789")
	svc := newDanmakuTestService(t)
	// 返回一个不存在的流服务地址模拟 Range 拉取失败
	svc.SetRemoteMediaResolver(func(_ context.Context, encodedID string) (*model.Media, string, error) {
		return &model.Media{
			Base:        model.Base{ID: remoteMediaID},
			Title:       "降级搜索番剧",
			EpisodeNum:  1,
			Path:        "/mnt/emby/anime/fallback/ep01.mkv",
			DurationSec: 1200,
		}, "http://127.0.0.1:1/invalid-stream", nil
	})

	ctx := context.Background()
	res, err := svc.Fetch(ctx, remoteMediaID, "", "")
	require.NoError(t, err)
	require.True(t, res.Enabled)
	require.Equal(t, "search", res.MatchMode)
	require.Equal(t, int64(7799), res.EpisodeID)
	require.Equal(t, "降级搜索番剧", res.AnimeTitle)
	require.Contains(t, res.Raw, "降级搜索弹幕")
}

// 即使刮削元数据完整，也应先走准确率最高的 hash 层。
func TestDanmakuFetchPrefersHashOverCompleteMetadata(t *testing.T) {
	videoPath, wantHash := writeDanmakuTestVideo(t, "测试动画.第01话.mkv")
	var seen string
	official := danmakuOfficialServer(t,
		`{"success":true,"isMatched":true,"matches":[{"episodeId":25484,"animeId":1001,"animeTitle":"官方测试动画","episodeTitle":"第1话"}]}`,
		`<?xml version="1.0"?><i><d p="0.5,1,16777215,user1">hash命中</d></i>`,
		&seen)
	overrideDanmakuOfficialBase(t, official.URL)

	source := newDanmakuSourceServerWithSearch(t,
		`{"hasMore":false,"animes":[{"animeId":2002,"animeTitle":"官方测试动画","episodes":[{"episodeId":25484,"episodeTitle":"第1话"}]}]}`)

	svc := newDanmakuTestService(t)
	ctx := context.Background()
	require.NoError(t, svc.repo.Setting.Set(ctx, DanmakuSourceKey, source.URL()))

	m := model.Media{
		Title:        "测试动画",
		Path:         videoPath,
		SizeBytes:    123,
		EpisodeNum:   1,
		EpisodeTitle: "起始与终结的序章",
		Year:         2011,
	}
	m.ID = "hash-first"
	require.NoError(t, svc.repo.DB.Create(&m).Error)

	res, err := svc.Fetch(ctx, "hash-first", "", "")
	require.NoError(t, err)
	require.Equal(t, "hash", res.MatchMode)
	require.NotEmpty(t, res.Raw)
	require.Contains(t, seen, wantHash)
}