// pvfdigestpair 把 etc/storydigest/digest.etc 每个段的 [scene] 列表从
// **累积列表**（1 2 3 ... N）改为**只含该段自己那一段**，使「剧情回顾」与
// 「章节过场影片」一对一配对。
//
// 动机：原结构里段 N 的 [scene] 是 1..N，玩家必须先看完前面所有回顾才看到
// 该段的 [ending] 影片。这既让回顾越堆越长，也让回顾一旦被改动就挡住过场。
//
// 改后：段 N 的 [scene] = N（只播该段回顾），随后播它自己的 [ending] 过场。
//
// 只改 [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 put32(b []byte, v uint32) { binary.LittleEndian.PutUint32(b, v) }

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, "只检查")
	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 令牌\n", len(raw), toks)

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

	// 遍历：每个段以 [level] 开始，含 [scene] <ints...> 与 [ending] <int>
	// 段序号按出现顺序 1,2,3...
	segIndex := 0
	var out []byte
	i := 0
	for i < toks {
		if isSec(i, refLevel) {
			segIndex++
			// 复制 [level] lo hi
			out = append(out, raw[i*5:(i+2)*5+5]...)
			i += 3
			continue
		}
		if isSec(i, refScene) {
			// 复制段头
			out = append(out, raw[i*5:i*5+5]...)
			i++
			// 跳过原列表（整数 token）
			start := i
			for i < toks && raw[i*5] == 0 {
				i++
			}
			// 写入新列表：只放本段序号
			out = append(out, tok5(0, uint32(segIndex))...)
			_ = start
			continue
		}
		// 其它 token 原样复制，跳过 [scene] 列表已处理的整数
		out = append(out, raw[i*5:i*5+5]...)
		i++
	}

	fmt.Printf("处理了 %d 个段，新大小 %d 字节 (%d 令牌)\n", segIndex, len(out), len(out)/5)

	// 校验：段数、[ending] 序列应与原来一致
	origEndings := []uint32{}
	for k := 0; k+1 < toks; k++ {
		if isSec(k, refEnding) {
			origEndings = append(origEndings, u32(raw[(k+1)*5+1:(k+1)*5+5]))
		}
	}
	newToks := len(out) / 5
	newEndings := []uint32{}
	newScenes := [][]uint32{}
	for k := 0; k+1 < newToks; k++ {
		if out[k*5] == 3 && u32(out[k*5+1:k*5+5]) == refEnding {
			newEndings = append(newEndings, 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 lst []uint32
			for j := k + 1; j < newToks && out[j*5] == 0; j++ {
				lst = append(lst, u32(out[j*5+1:j*5+5]))
			}
			newScenes = append(newScenes, lst)
		}
	}
	fmt.Printf("[ending] 数量 原=%d 新=%d\n", len(origEndings), len(newEndings))
	if len(origEndings) != len(newEndings) {
		panic("ending 数量不一致")
	}
	for k := range origEndings {
		if origEndings[k] != newEndings[k] {
			panic(fmt.Sprintf("第 %d 个 ending 变了: %d → %d", k+1, origEndings[k], newEndings[k]))
		}
	}
	fmt.Println("全部 [ending] 保持原值 ✅")
	fmt.Println("[scene] 新列表（每段只含自己）:")
	for k, l := range newScenes {
		fmt.Printf("  段%-3d [scene] %v\n", k+1, l)
	}

	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), "字节")
	_ = put32
}