package rond

import (
	"strings"
	"testing"
	"time"
)

func tp(s string) *time.Time {
	t, err := time.Parse("2006-01-02 15:04", s)
	if err != nil {
		panic(err)
	}
	return &t
}

func ip(v int) *int { return &v }

// 两组编号刻意完全不同：rond 每次导出都会重排 Z_PK，对齐只能靠 UUID。
const (
	uuidA = "11111111111111111111111111111111"
	uuidB = "22222222222222222222222222222222"
	uuidC = "33333333333333333333333333333333"
)

func sampleBackup() *Backup {
	return &Backup{
		Visits: []Visit{
			{SrcPK: 555, Arrival: tp("2026-09-01 10:00"), Departure: tp("2026-09-01 11:00"),
				LocationSrcPK: ip(3), ActivitySrcPK: ip(7)},
			{SrcPK: 556, Arrival: tp("2026-09-02 10:00"), LocationSrcPK: ip(3)},
		},
		Locations: []Location{
			{SrcPK: 3, Name: "家", Lat: 24.1, Lon: 109.1, City: "柳州市"},
			{SrcPK: 4, Name: "公司", Lat: 24.2, Lon: 109.2, City: "柳州市"},
		},
		Activities: []Activity{
			{SrcPK: 7, Name: "工作"},
			{SrcPK: 8, Name: "散步"},
		},
		VisitUUID:    map[int]string{555: uuidA, 556: uuidB},
		ActivityUUID: map[int]string{7: uuidC},
	}
}

func TestDiffVisitsAlignsByUUIDNotPK(t *testing.T) {
	stored := []StoredVisit{
		{SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"), Departure: tp("2026-09-01 11:00"),
			PlaceKey: PlaceCoordKey(24.1, 109.1), ActivityName: "工作"},
		{SrcPK: 2, UUID: uuidB, Arrival: tp("2026-09-02 10:00"),
			PlaceKey: PlaceCoordKey(24.1, 109.1)},
	}
	d := DiffVisits(stored, sampleBackup())
	if len(d.Added) != 0 || len(d.Removed) != 0 || len(d.Changed) != 0 {
		t.Fatalf("两边一致时不该有差异: +%d -%d ~%d", len(d.Added), len(d.Removed), len(d.Changed))
	}
	if d.Same != 2 {
		t.Fatalf("应配上 2 条，实际 %d", d.Same)
	}
}

func TestDiffVisitsFieldChanges(t *testing.T) {
	stored := []StoredVisit{{
		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 09:00"), Departure: tp("2026-09-01 11:00"),
		PlaceKey: PlaceCoordKey(24.1, 109.1), ActivityName: "工作", Remark: "站点备注",
	}}
	d := DiffVisits(stored, sampleBackup())
	if len(d.Changed) != 1 {
		t.Fatalf("到达时间不同应算冲突，实际 %d 条", len(d.Changed))
	}
	f := d.Changed[0].Fields
	if len(f) != 2 {
		t.Fatalf("应报出到达时间与备注两项，实际 %v", f)
	}
	if f[0].Label != "到达时间" || f[1].Label != "备注" {
		t.Fatalf("字段名不对: %v", f)
	}
	if f[1].From != "站点备注" || f[1].To != "" {
		t.Fatalf("方向搞反了（From 应是库里的值）: %+v", f[1])
	}
}

// 站点新建的到访没有 UUID，而且它的 src_pk 很可能与真机新行的编号撞上——
// 绝不能因为编号相同就当成同一条。
func TestDiffVisitsIgnoresPKCollision(t *testing.T) {
	stored := []StoredVisit{{
		SrcPK: 555, UUID: "", Arrival: tp("2026-08-01 08:00"), UserAdded: true,
		PlaceKey: PlaceCoordKey(30.0, 120.0),
	}}
	d := DiffVisits(stored, sampleBackup())
	if len(d.Added) != 2 {
		t.Fatalf("备份里两条都是新增，实际 %d", len(d.Added))
	}
	if len(d.Removed) != 1 {
		t.Fatalf("站点补录那条应算「仅库里有」，实际 %d", len(d.Removed))
	}
	if !d.Removed[0].UserAdded {
		t.Error("站点补录的标记要带上，页面上要区分开")
	}
}

// 真机偶尔有不带 UUID 的到访，只按 UUID 配对会让同一条既算新增又算仅站内有。
func TestDiffVisitsFallsBackWhenUUIDMissing(t *testing.T) {
	b := &Backup{
		Visits: []Visit{
			{SrcPK: 900, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)},
			{SrcPK: 901, Arrival: tp("2026-09-02 10:00"), LocationSrcPK: ip(3)},
		},
		Locations:    []Location{{SrcPK: 3, Name: "家", Lat: 24.1, Lon: 109.1}},
		VisitUUID:    map[int]string{}, // 一条都没有 UUID
		ActivityUUID: map[int]string{},
	}
	stored := []StoredVisit{
		{SrcPK: 1, Arrival: tp("2026-09-01 10:00"), PlaceKey: PlaceCoordKey(24.1, 109.1)},
		{SrcPK: 2, Arrival: tp("2026-09-02 10:00"), PlaceKey: PlaceCoordKey(24.1, 109.1)},
	}
	d := DiffVisits(stored, b)
	if len(d.Added) != 0 || len(d.Removed) != 0 {
		t.Fatalf("没有 UUID 时应按「到达时间 + 地点」兜底配对: +%d -%d", len(d.Added), len(d.Removed))
	}
	if d.Same != 2 {
		t.Fatalf("两条都该配上，实际 %d", d.Same)
	}
}

// 站点补录的行（没有留档 UUID）导出过一次之后，包里那条带着的是站点给它补的派生 UUID。
// 这份包再合并回来时，必须认出「这就是我导出去的那条」——不认就会当成「备份新增」又插一条，
// 时间线上于是出现两条一模一样的到访（实测数据集 9 有 43 对）。
func TestDiffVisitsAlignsSiteCreatedRowByDerivedUUID(t *testing.T) {
	const srcPK = 42
	b := &Backup{
		Visits:       []Visit{{SrcPK: 900, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)}},
		Locations:    []Location{{SrcPK: 3, Name: "家", Lat: 24.1, Lon: 109.1}},
		VisitUUID:    map[int]string{900: DerivedVisitUUID(srcPK)}, // 导出时补给这条的
		ActivityUUID: map[int]string{},
	}
	stored := []StoredVisit{{
		SrcPK: srcPK, UUID: "", // 站点补录：entity_raw 里没有这一行
		Arrival: tp("2026-09-01 10:00"), PlaceKey: PlaceCoordKey(24.1, 109.1),
	}}
	d := DiffVisits(stored, b)
	if len(d.Added) != 0 || len(d.Removed) != 0 {
		t.Fatalf("该认出是同一行（派生 UUID 对上了）: +%d -%d", len(d.Added), len(d.Removed))
	}
	if d.Same != 1 {
		t.Fatalf("应配上 1 条，实际 same=%d changed=%d", d.Same, len(d.Changed))
	}
}

// 反例：派生 UUID 是别的编号的，就不该被认领（否则会把两条不同的到访混成一条）。
func TestDiffVisitsDoesNotAlignOtherDerivedUUID(t *testing.T) {
	const srcPK = 42
	b := &Backup{
		Visits:    []Visit{{SrcPK: 900, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)}},
		Locations: []Location{{SrcPK: 3, Name: "家", Lat: 24.1, Lon: 109.1}},
		VisitUUID: map[int]string{900: DerivedVisitUUID(srcPK + 1)},
	}
	stored := []StoredVisit{{
		SrcPK: srcPK, Arrival: tp("2026-09-01 10:00"), PlaceKey: PlaceCoordKey(24.1, 109.1),
	}}
	d := DiffVisits(stored, b)
	if len(d.Added) != 1 || len(d.Removed) != 1 {
		t.Fatalf("派生 UUID 对不上就该分别报出: +%d -%d", len(d.Added), len(d.Removed))
	}
}

// 兜底配对要认得出「同一条但时间被改过」——时间不同就配不上，此时按新增 + 仅站内有报出，
// 总比静默当成同一条好。
func TestDiffVisitsFallbackNeedsSameTime(t *testing.T) {
	b := &Backup{
		Visits:    []Visit{{SrcPK: 900, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)}},
		Locations: []Location{{SrcPK: 3, Name: "家", Lat: 24.1, Lon: 109.1}},
		VisitUUID: map[int]string{},
	}
	stored := []StoredVisit{{SrcPK: 1, Arrival: tp("2026-09-01 11:00"), PlaceKey: PlaceCoordKey(24.1, 109.1)}}
	d := DiffVisits(stored, b)
	if len(d.Added) != 1 || len(d.Removed) != 1 {
		t.Fatalf("时间对不上时该分别报出: +%d -%d", len(d.Added), len(d.Removed))
	}
}

func TestDiffVisitsSkipsRowsWithoutArrival(t *testing.T) {
	b := sampleBackup()
	b.Visits = append(b.Visits, Visit{SrcPK: 557, LocationSrcPK: ip(3)})
	d := DiffVisits(nil, b)
	if len(d.Added) != 2 {
		t.Fatalf("没有到达时间的行导入时就被跳过，不该算新增，实际 %d", len(d.Added))
	}
}

func TestDiffPlacesByKey(t *testing.T) {
	b := sampleBackup()
	stored := []StoredPlace{
		{SrcPK: 10, Key: PlaceCoordKey(24.1, 109.1), Name: "家", Lat: 24.1, Lon: 109.1, City: "柳州市"},
	}
	d := DiffPlaces(stored, b)
	if len(d.Added) != 1 || d.Added[0].Name != "公司" {
		t.Fatalf("应只有「公司」是新增: %+v", d.Added)
	}
	if len(d.Removed) != 0 || len(d.Changed) != 0 || d.Same != 1 {
		t.Fatalf("「家」应配上且无差异: same=%d changed=%d removed=%d", d.Same, len(d.Changed), len(d.Removed))
	}
}

func TestDiffPlacesReportsFieldChanges(t *testing.T) {
	b := sampleBackup()
	stored := []StoredPlace{
		{SrcPK: 10, Key: PlaceCoordKey(24.1, 109.1), Name: "家", Lat: 24.1, Lon: 109.1, City: "桂林市"},
	}
	d := DiffPlaces(stored, b)
	if len(d.Changed) != 1 {
		t.Fatalf("城市不同应算冲突，实际 %d", len(d.Changed))
	}
	if f := d.Changed[0].Fields; len(f) != 1 || f[0].Label != "城市" || f[0].From != "桂林市" || f[0].To != "柳州市" {
		t.Fatalf("字段差异不对: %+v", f)
	}
}

func TestDiffActivities(t *testing.T) {
	b := sampleBackup()
	stored := []StoredActivity{
		{SrcPK: 20, Name: "工作", UUID: uuidC},
		{SrcPK: 21, Name: "站点自建"},
	}
	d := DiffActivities(stored, b)
	if len(d.Added) != 1 || d.Added[0].Name != "散步" {
		t.Fatalf("「散步」应是新增: %+v", d.Added)
	}
	if len(d.Removed) != 1 || d.Removed[0].Name != "站点自建" {
		t.Fatalf("站点自建的活动应算仅库里有: %+v", d.Removed)
	}
	if d.Same != 1 {
		t.Fatalf("「工作」应配上，实际 same=%d", d.Same)
	}
}

// 活动改了名：UUID 还在，就该认出来是同一个，只报名称变化，而不是「删一个加一个」。
func TestDiffActivitiesRenameByUUID(t *testing.T) {
	b := sampleBackup()
	stored := []StoredActivity{{SrcPK: 20, Name: "上班", UUID: uuidC}}
	d := DiffActivities(stored, b)
	if len(d.Added) != 1 || len(d.Removed) != 0 {
		t.Fatalf("只该多出「散步」，「上班」应认出是同一个: +%d -%d", len(d.Added), len(d.Removed))
	}
	if len(d.Changed) != 1 || d.Changed[0].Fields[0].From != "上班" || d.Changed[0].Fields[0].To != "工作" {
		t.Fatalf("应按 UUID 认出重命名: %+v", d.Changed)
	}
}

func TestPlaceCoordKeyStable(t *testing.T) {
	a := PlaceCoordKey(24.1, 109.1)
	if a != PlaceCoordKey(24.1, 109.1) {
		t.Fatal("同样的输入应得到同样的键")
	}
	if a == PlaceCoordKey(24.1, 109.2) {
		t.Fatal("坐标不同不该算同一个地点")
	}
}

// 站点把地点反查改名（坐标没动）时，到访层面不该报「换了地点」——
// 实测里这一条会让 17 条到访全变成假冲突。
func TestDiffVisitsIgnoresPlaceRename(t *testing.T) {
	b := &Backup{
		Visits:    []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)}},
		Locations: []Location{{SrcPK: 3, Name: "河池市国民体质监测中心", Lat: 24.691827, Lon: 108.035268}},
		VisitUUID: map[int]string{5: uuidA},
	}
	stored := []StoredVisit{{
		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"),
		PlaceKey: PlaceCoordKey(24.691827, 108.035268), PlaceName: "体育馆美食街",
	}}
	d := DiffVisits(stored, b)
	if len(d.Changed) != 0 {
		t.Fatalf("只改了地点名不该算到访冲突: %+v", d.Changed[0].Fields)
	}
	if d.Same != 1 {
		t.Fatalf("应算作一致，实际 same=%d", d.Same)
	}
}

// 反之，地点层面要把改名报出来。
func TestDiffPlacesReportsRename(t *testing.T) {
	b := &Backup{Locations: []Location{
		{SrcPK: 3, Name: "河池市国民体质监测中心", Lat: 24.691827, Lon: 108.035268, City: "河池市"},
	}}
	stored := []StoredPlace{{
		SrcPK: 10, Key: PlaceCoordKey(24.691827, 108.035268), Name: "体育馆美食街",
		Lat: 24.691827, Lon: 108.035268, City: "河池市",
	}}
	d := DiffPlaces(stored, b)
	if len(d.Added) != 0 || len(d.Removed) != 0 {
		t.Fatalf("坐标一样就是同一个地点: +%d -%d", len(d.Added), len(d.Removed))
	}
	if len(d.Changed) != 1 {
		t.Fatalf("改名应报成一条冲突，实际 %d", len(d.Changed))
	}
	f := d.Changed[0].Fields
	if len(f) != 1 || f[0].Label != "名称" || f[0].From != "体育馆美食街" || f[0].To != "河池市国民体质监测中心" {
		t.Fatalf("字段差异不对: %+v", f)
	}
}

// 没有坐标的地点不能都落到同一个键上，否则两个不同地点会互相认领。
func TestDiffPlacesWithoutCoordDoesNotCollide(t *testing.T) {
	b := &Backup{Locations: []Location{{SrcPK: 3, Name: "甲地"}}}
	stored := []StoredPlace{
		{SrcPK: 10, Name: "甲地"},
		{SrcPK: 11, Name: "乙地"},
	}
	d := DiffPlaces(stored, b)
	if len(d.Added) != 0 || len(d.Removed) != 1 {
		t.Fatalf("应只配上同名的「甲地」: +%d -%d", len(d.Added), len(d.Removed))
	}
	if d.Removed[0].Name != "乙地" {
		t.Fatalf("没配上的应是「乙地」，实际 %q", d.Removed[0].Name)
	}
	if d.Same != 1 {
		t.Fatalf("「甲地」应算一致，实际 %d", d.Same)
	}
}

// 站点把坐标纠偏过（名称没变）也要认得出是同一个地点。
func TestDiffPlacesMatchesByNameWhenCoordMoved(t *testing.T) {
	b := &Backup{Locations: []Location{{SrcPK: 3, Name: "家", Lat: 24.100001, Lon: 109.100001}}}
	stored := []StoredPlace{{
		SrcPK: 10, Key: PlaceCoordKey(24.1, 109.1), Name: "家", Lat: 24.1, Lon: 109.1,
	}}
	d := DiffPlaces(stored, b)
	if len(d.Added) != 0 || len(d.Removed) != 0 {
		t.Fatalf("名称一样就该配上: +%d -%d", len(d.Added), len(d.Removed))
	}
	if len(d.Changed) != 1 || d.Changed[0].Fields[0].Label != "纬度" {
		t.Fatalf("应报出坐标差异: %+v", d.Changed)
	}
}

// 真机一个坐标下会有好几条同名同坐标的地点（实测「柳州站」同一个坐标 3 条，备份里这类分组共 10 组）。
// 用单槽位 map 时，同一坐标最多只能配上一条，第 3 条永远判「备份新增」→ 每次合并都再插一条
// 重复地点、差异永远归不了零。
func TestDiffPlacesAlignsDuplicateNameCoordGroups(t *testing.T) {
	loc := func(pk int) Location {
		return Location{SrcPK: pk, Name: "柳州站", Lat: 24.307787, Lon: 109.388309}
	}
	sp := func(pk int) StoredPlace {
		return StoredPlace{SrcPK: pk, Key: PlaceCoordKey(24.307787, 109.388309),
			Name: "柳州站", Lat: 24.307787, Lon: 109.388309}
	}
	b := &Backup{Locations: []Location{loc(41), loc(42), loc(43)}}

	d := DiffPlaces([]StoredPlace{sp(11), sp(12), sp(13)}, b)
	if len(d.Added) != 0 || len(d.Removed) != 0 || len(d.Changed) != 0 {
		t.Fatalf("两边各 3 条同名同坐标应一一配上: +%d -%d ~%d", len(d.Added), len(d.Removed), len(d.Changed))
	}
	if d.Same != 3 {
		t.Fatalf("应配上 3 条，实际 %d", d.Same)
	}

	// 反过来：站内真的少两条时，仍要老老实实报出「备份新增 2」——
	// 多值配对不能变成「只要有同名同坐标就一律不算新增」。
	d = DiffPlaces([]StoredPlace{sp(11)}, b)
	if len(d.Added) != 2 || len(d.Removed) != 0 || d.Same != 1 {
		t.Fatalf("站内只有 1 条时应报新增 2: +%d -%d same=%d", len(d.Added), len(d.Removed), d.Same)
	}
}

// 活动改了名（UUID 还在）：那是活动层的差异，不该在挂着它的每条到访上重复报一遍。
// 实测真机 16 个活动改名会把 355 条到访全变成假冲突，而且逐条选「用实机」也改不掉活动名。
func TestDiffVisitsIgnoresActivityRename(t *testing.T) {
	b := &Backup{
		Visits:       []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), ActivitySrcPK: ip(7)}},
		Activities:   []Activity{{SrcPK: 7, Name: "吃饭"}},
		VisitUUID:    map[int]string{5: uuidA},
		ActivityUUID: map[int]string{7: uuidC},
	}
	stored := []StoredVisit{{
		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"),
		ActivityName: "餐厅", ActivityUUID: uuidC,
	}}
	d := DiffVisits(stored, b)
	if len(d.Changed) != 0 {
		t.Fatalf("同一个活动改名不该算到访冲突: %+v", d.Changed[0].Fields)
	}
	if d.Same != 1 {
		t.Fatalf("应算作一致，实际 same=%d", d.Same)
	}
}

// 换成了另一个活动才是真差异。
func TestDiffVisitsReportsActivityChange(t *testing.T) {
	b := &Backup{
		Visits:       []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), ActivitySrcPK: ip(7)}},
		Activities:   []Activity{{SrcPK: 7, Name: "吃饭"}, {SrcPK: 8, Name: "散步"}},
		VisitUUID:    map[int]string{5: uuidA},
		ActivityUUID: map[int]string{7: uuidC, 8: uuidB},
	}
	stored := []StoredVisit{{
		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"),
		ActivityName: "散步", ActivityUUID: uuidB,
	}}
	d := DiffVisits(stored, b)
	if len(d.Changed) != 1 {
		t.Fatalf("换了活动该报冲突，实际 %d 条", len(d.Changed))
	}
	f := d.Changed[0].Fields
	if len(f) != 1 || f[0].Label != "活动" || f[0].From != "散步" || f[0].To != "吃饭" {
		t.Fatalf("活动差异不对: %+v", f)
	}
}

// 站点自建的活动没有 UUID，退不回身份就按名称比（老数据要保持原样）。
func TestDiffVisitsActivityWithoutUUIDFallsBackToName(t *testing.T) {
	b := &Backup{
		Visits:       []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), ActivitySrcPK: ip(7)}},
		Activities:   []Activity{{SrcPK: 7, Name: "吃饭"}},
		VisitUUID:    map[int]string{5: uuidA},
		ActivityUUID: map[int]string{7: uuidC},
	}
	// 名称一致 → 不报
	same := []StoredVisit{{
		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"), ActivityName: "吃饭",
	}}
	if d := DiffVisits(same, b); len(d.Changed) != 0 {
		t.Fatalf("名称相同时不该报冲突: %+v", d.Changed[0].Fields)
	}
	// 名称不同 → 报
	diff := []StoredVisit{{
		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"), ActivityName: "散步",
	}}
	d := DiffVisits(diff, b)
	if len(d.Changed) != 1 || d.Changed[0].Fields[0].Label != "活动" {
		t.Fatalf("没有 UUID 时应退回按名称比: %+v", d.Changed)
	}
}

// 名称兜底配对必须有距离上限：连锁店同名（中国体育彩票、茶颜悦色…）时，坐标配不上的
// 两条相隔几百公里的同名地点绝不能配成一对——一勾「用实机」就把站内那条搬到另一座城市。
// 实测踩过：佛山的「中国体育彩票」(22.927572,113.222052) 被配给贺州那条
// (24.408376,111.554626)（直线 236.8km），合并后站内地点从贺州搬到了佛山。
func TestDiffPlacesNameFallbackNeedsNearby(t *testing.T) {
	b := &Backup{Locations: []Location{
		{SrcPK: 41, Name: "中国体育彩票", Lat: 24.408376, Lon: 111.554626, City: "贺州市"},
	}}
	stored := []StoredPlace{
		{SrcPK: 11, Key: PlaceCoordKey(22.927572, 113.222052), Name: "中国体育彩票",
			Lat: 22.927572, Lon: 113.222052, City: "佛山市"},
	}
	d := DiffPlaces(stored, b)
	if len(d.Changed) != 0 {
		t.Fatalf("相隔 236.8km 的同名地点不该被配对: %+v", d.Changed[0].Fields)
	}
	if len(d.Added) != 1 || len(d.Removed) != 1 {
		t.Fatalf("应报成「备份新增 + 仅站内有」: +%d -%d", len(d.Added), len(d.Removed))
	}
}

// 但坐标纠偏那种（同一地点，两边差几百米）仍要配上——名称兜底本来就是为它准备的。
func TestDiffPlacesNameFallbackKeepsNearbyCoordFix(t *testing.T) {
	b := &Backup{Locations: []Location{
		{SrcPK: 41, Name: "茶颜悦色", Lat: 28.181954, Lon: 112.986995},
	}}
	stored := []StoredPlace{
		{SrcPK: 11, Key: PlaceCoordKey(28.185360, 112.981422), Name: "茶颜悦色",
			Lat: 28.185360, Lon: 112.981422},
	}
	d := DiffPlaces(stored, b)
	if len(d.Added) != 0 || len(d.Removed) != 0 {
		t.Fatalf("相距 665m 的同名地点应配上: +%d -%d", len(d.Added), len(d.Removed))
	}
	if len(d.Changed) != 1 || d.Changed[0].Fields[0].Label != "纬度" {
		t.Fatalf("应报出坐标差异: %+v", d.Changed)
	}
}

// 多条同名备份地点必须**一条配一条**（各配最近的那条），不能全并到同一条站内地点上：
// 合并执行（mergePlaces）沿用的就是这份配对，并错了到访就会挂到错的分店
// （实测「茶颜悦色」两家分店相隔 8.3km，到访却指向同一条）。
func TestMatchPlacesKeepsDuplicateNameGroupsDistinct(t *testing.T) {
	mk := func(pk int, lat, lon float64) StoredPlace {
		sp := StoredPlace{SrcPK: pk, Name: "茶颜悦色", Lat: lat, Lon: lon}
		sp.Key = PlaceCoordKey(lat, lon)
		return sp
	}
	stored := []StoredPlace{
		mk(11, 28.185360, 112.981422), // 与备份 #41 相距约 665m
		mk(12, 28.245842, 113.031303), // 与备份 #42 相距约 670m
	}
	backup := []Location{
		{SrcPK: 41, Name: "茶颜悦色", Lat: 28.181954, Lon: 112.986995},
		{SrcPK: 42, Name: "茶颜悦色", Lat: 28.242581, Lon: 113.037061},
	}
	m := MatchPlaces(stored, backup)
	if len(m) != 2 {
		t.Fatalf("两条都该配上，实际 %d", len(m))
	}
	if m[41].SrcPK == m[42].SrcPK {
		t.Fatalf("两条同名备份地点被并到了同一条站内地点上: 41→%d 42→%d", m[41].SrcPK, m[42].SrcPK)
	}
	if m[41].SrcPK != 11 || m[42].SrcPK != 12 {
		t.Fatalf("应各配最近的一条（41→11、42→12），实际 41→%d 42→%d", m[41].SrcPK, m[42].SrcPK)
	}

	// 两家分店挨得近（都在 1km 内）时也要一条配一条：坐标键对不上、只能靠名称兜底，
	// 若认领了却不标记已用，两条会双双落到第一条上。
	near := []StoredPlace{mk(21, 1.000000, 1.000000), mk(22, 1.005000, 1.005000)}
	closeBy := []Location{
		{SrcPK: 51, Name: "茶颜悦色", Lat: 1.002400, Lon: 1.002400},
		{SrcPK: 52, Name: "茶颜悦色", Lat: 1.002600, Lon: 1.002600},
	}
	m2 := MatchPlaces(near, closeBy)
	if len(m2) != 2 {
		t.Fatalf("两条都该配上，实际 %d", len(m2))
	}
	if m2[51].SrcPK == m2[52].SrcPK {
		t.Fatalf("两条同名备份地点被并到了同一条站内地点上: 51→%d 52→%d", m2[51].SrcPK, m2[52].SrcPK)
	}
}

// 「地点」这一项比的是坐标，只印名称时同名不同坐标会渲染成「X → X」，站长看不出差在哪。
// 名称一样就必须把坐标带出来。
func TestDiffVisitsPlaceConflictShowsCoords(t *testing.T) {
	b := &Backup{
		Visits:    []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)}},
		Locations: []Location{{SrcPK: 3, Name: "长沙南站", Lat: 28.141772, Lon: 113.067569}},
		VisitUUID: map[int]string{5: uuidA},
	}
	stored := []StoredVisit{{
		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"),
		PlaceName: "长沙南站", PlaceKey: PlaceCoordKey(28.146535, 113.062164),
	}}
	d := DiffVisits(stored, b)
	if len(d.Changed) != 1 {
		t.Fatalf("坐标不同应算冲突，实际 %d 条", len(d.Changed))
	}
	f := d.Changed[0].Fields
	if len(f) != 1 || f[0].Label != "地点" {
		t.Fatalf("应只报一项地点差异: %+v", f)
	}
	for _, want := range []string{"长沙南站", "28.146535", "113.062164"} {
		if !strings.Contains(f[0].From, want) {
			t.Fatalf("站内那侧 %q 应含 %q（否则这一行看着像没变化）", f[0].From, want)
		}
	}
	for _, want := range []string{"长沙南站", "28.141772", "113.067569"} {
		if !strings.Contains(f[0].To, want) {
			t.Fatalf("备份那侧 %q 应含 %q", f[0].To, want)
		}
	}
}