// pvfdigestscenetofilm 把 etc/storydigest/digest.etc 每个段的 [scene] 列表
// 改为**直接指向承载该段章节过场的影片段**（900+段序号）。
//
// 动机：客户端把 [scene] 与 [ending] 当作**同一个播放序列的连续步骤**。
// 若 [scene] 指向"剧情回顾"段，玩家必须先看完回顾；若把回顾段内容清空，
// 序列会在回顾那步中断，导致后面的 [ending] 过场也播不出来（实测）。
//
// 改后：[scene] = 900+序号（即该段自己的 [ending] 影片段），
//       客户端播 [scene] 时拿到的就是影片，回顾完全不参与，序列不中断。
//
// 只改 [scene] 列表的整数；段号、[level]、[ending] 全部不动。
package main

import (
	"encoding/binary"
	"flag"
	"fmt"
	"os"
	"path/filepath"

	platformpvf "longheng.io/server/internal/platform/pvf"
)

const (
	refScene  = uint32(0x025138C6) // "[scene]"
	refEnding = uint32(0x025138D6) // "[ending]"
	refLevel  = uint32(0x003566E2) // "[level]"
)

func u32(b []byte) uint32 { return binary.LittleEndian.Uint32(b) }

func tok5(typ byte, ref uint32) []byte {
	b := make([]byte, 5)
	b[0] = typ
	binary.LittleEndian.PutUint32(b[1:], ref)
	return b
}

func main() {
	input := flag.String("pvf", "", "input PVF")
	dir := flag.String("dir", "", "raw patch dir")
	dry := flag.Bool("dry-run", false, "只检查")
	base := flag.Uint("base", 900, "影片段号基数（结束段号 = base + 段序号）")
	flag.Parse()
	archive, err := platformpvf.Open(*input)
	if err != nil {
		panic(err)
	}
	raw, err := archive.ReadRaw("etc/storydigest/digest.etc")
	if err != nil {
		panic(err)
	}
	toks := len(raw) / 5
	fmt.Printf("digest.etc %d 字节 %d 令牌，基数=%d\n", len(raw), toks, *base)

	isSec := func(i int, ref uint32) bool {
		return i < toks && raw[i*5] == 3 && u32(raw[i*5+1:i*5+5]) == ref
	}

	segIndex := 0
	var out []byte
	i := 0
	// 先把每个段的 [ending] 值抽出来（段序号从 1 起），用于填 [scene]
	endingBySeg := map[int]uint32{}
	{
		n := 0
		for k := 0; k+1 < toks; k++ {
			if isSec(k, refLevel) {
				n++
			}
			if isSec(k, refEnding) {
				endingBySeg[n] = u32(raw[(k+1)*5+1 : (k+1)*5+5])
			}
		}
	}
	for i < toks {
		if isSec(i, refLevel) {
			segIndex++
			out = append(out, raw[i*5:(i+2)*5+5]...) // [level] lo hi
			i += 3
			continue
		}
		if isSec(i, refScene) {
			out = append(out, raw[i*5:i*5+5]...) // 段头
			i++
			for i < toks && raw[i*5] == 0 { // 丢弃原列表
				i++
			}
			// 新列表：直接指向**该段自己的 [ending] 影片段**
			out = append(out, tok5(0, endingBySeg[segIndex])...)
			continue
		}
		out = append(out, raw[i*5:i*5+5]...)
		i++
	}
	fmt.Printf("处理 %d 个段，新大小 %d 字节 (%d 令牌)\n", segIndex, len(out), len(out)/5)

	// 校验：ending 序列不变
	origEnd, newEnd := []uint32{}, []uint32{}
	for k := 0; k+1 < toks; k++ {
		if isSec(k, refEnding) {
			origEnd = append(origEnd, u32(raw[(k+1)*5+1:(k+1)*5+5]))
		}
	}
	nt := len(out) / 5
	scenes := [][]uint32{}
	for k := 0; k+1 < nt; k++ {
		if out[k*5] == 3 && u32(out[k*5+1:k*5+5]) == refEnding {
			newEnd = append(newEnd, u32(out[(k+1)*5+1:(k+1)*5+5]))
		}
		if out[k*5] == 3 && u32(out[k*5+1:k*5+5]) == refScene {
			var l []uint32
			for j := k + 1; j < nt && out[j*5] == 0; j++ {
				l = append(l, u32(out[j*5+1:j*5+5]))
			}
			scenes = append(scenes, l)
		}
	}
	if len(origEnd) != len(newEnd) {
		panic("ending 数量不一致")
	}
	for k := range origEnd {
		if origEnd[k] != newEnd[k] {
			panic(fmt.Sprintf("第 %d 个 ending 变了", k+1))
		}
	}
	fmt.Println("全部 [ending] 保持原值 ✅")
	for k, l := range scenes {
		fmt.Printf("  段%-3d [scene] %v  [ending] %d\n", k+1, l, newEnd[k])
	}

	if *dry {
		fmt.Println("dry-run，未写文件")
		return
	}
	full := filepath.Join(*dir, "etc", "storydigest", "digest.etc")
	if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
		panic(err)
	}
	if err := os.WriteFile(full, out, 0o644); err != nil {
		panic(err)
	}
	fmt.Println("已写出", full, len(out), "字节")
}