// 弹幕录制相关
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"

	"github.com/orzogc/acfundanmu"
)

// 不同的视频分辨率对应的弹幕字幕设置
var subConfigs = map[int]acfundanmu.SubConfig{
	0:    {PlayResX: 720, PlayResY: 1280, FontSize: 60}, // 这是手机直播，有一些是 540X960
	540:  {PlayResX: 960, PlayResY: 540, FontSize: 30},
	720:  {PlayResX: 1280, PlayResY: 720, FontSize: 40},
	1080: {PlayResX: 1920, PlayResY: 1080, FontSize: 60},
}

// 获取弹幕字幕设置，根据直播源的码率选择
func (s *streamer) getSubConfig() (cfg acfundanmu.SubConfig, e error) {
	defer func() {
		if err := recover(); err != nil {
			e = fmt.Errorf("getSubConfig() error: %v", err)
		}
	}()

	var ac *acfundanmu.AcFunLive
	var err error
	err = runThrice(func() error {
		ac, err = acfundanmu.NewAcFunLive(acfundanmu.SetLiverUID(int64(s.UID)))
		return err
	})
	checkErr(err)
	sInfo := ac.GetStreamInfo()

	// 选择码率最高的直播源
	index := len(sInfo.StreamList) - 1
	bitrate := sInfo.StreamList[index].Bitrate
	switch {
	case bitrate >= 4000:
		cfg = subConfigs[1080]
	case len(sInfo.StreamList) >= 2 && bitrate >= 2000:
		cfg = subConfigs[720]
	case bitrate == 0:
		cfg = subConfigs[0]
	default:
		cfg = subConfigs[540]
	}

	return cfg, nil
}

// ==================== 弹幕数据双路输出 ====================

// 弹幕持续时间（纳秒），与 acfundanmu 保持一致
const danmuShowDur = int64(10 * time.Second)

// 弹道数量上限，与 acfundanmu 的 queueLen 保持一致
const laneNum = 100

// ass 文件的 Script Info，与 acfundanmu 保持一致
const scriptInfoTmpl = `[Script Info]
; LiveID: %s
; StreamName: %s
Title: %s
ScriptType: v4.00+
Collisions: Normal
PlayResX: %d
PlayResY: %d

`

// ass 文件的 V4+ Styles，与 acfundanmu 保持一致
const stylesTmpl = `[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Danmu,Microsoft YaHei,%d,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,1,0,2,20,20,2,0

`

// ass 文件的 Events
const eventsTmpl = `[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
`

// 原格式弹幕行，与 acfundanmu 的 dialogue 保持一致
const dialogueTmpl = "Dialogue: 0,%s,%s,Danmu,%s(%d),20,20,2,,{\\move(%d,%d,%d,%d)}%s\n"

// 昵称头像版弹幕行，\an7 让锚点固定在文本左上角，前导全角空格是头像占位
const dialogueNickTmpl = "Dialogue: 0,%s,%s,Danmu,%s(%d),20,20,2,,{\\an7\\move(%d,%d,%d,%d)}%s\n"

// jsonl 首行的元数据
type danmuMeta struct {
	PlayResX  int   `json:"playResX"`
	PlayResY  int   `json:"playResY"`
	FontSize  int   `json:"fontSize"`
	StartTime int64 `json:"startTime"` // 录制开始的时间，纳秒 Unix
}

// jsonl 的弹幕记录
type danmuRecord struct {
	Time    float64 `json:"t"` // 相对录制开始的秒数
	UID     int64   `json:"uid"`
	Name    string  `json:"name"`
	Avatar  string  `json:"avatar"` // 头像 URL，弹幕协议自带
	Content string  `json:"content"`
	Lane    int     `json:"lane"`  // 在昵称头像版 ASS 里的弹道行
	Width   int     `json:"width"` // 昵称头像版文本的估算像素宽度
}

// 弹道的占用状态（纳秒）
type laneState struct {
	appear    int64
	emerge    int64
	disappear int64
}

// ass 文件里弹幕出现或消失的时间格式，与 acfundanmu 保持一致
type assTime int64

func (t assTime) String() string {
	if t < 0 {
		return "0:00:00.00"
	}
	tt := time.Unix(0, int64(t)).UTC()
	return fmt.Sprintf("%d:%02d:%02d.%02d", tt.Hour(), tt.Minute(), tt.Second(), tt.Nanosecond()/1e7)
}

// 估算文本的渲染宽度，CJK 及全角字符按全宽、其余按半宽计算
func textWidth(text string, fontSize int) int {
	w := 0
	for _, r := range text {
		if r >= 0x2E80 {
			w += fontSize
		} else {
			w += fontSize / 2
		}
	}
	return w
}

// 在弹道数组里寻找空闲弹道，返回弹道行号，没有空闲返回 -1，公式与 acfundanmu 保持一致
func placeLane(last []laneState, dt laneState, leftTime int64) int {
	for i, t := range last {
		if dt.appear > t.emerge && leftTime > t.disappear {
			last[i] = dt
			return i
		}
	}
	return -1
}

// 弹幕数据双路输出：原格式 ASS + 昵称头像版 ASS + jsonl
type danmuWriter struct {
	cfg   acfundanmu.SubConfig
	ass   *os.File // 原格式
	nick  *os.File // 昵称头像版
	jsonl *os.File
	lastO []laneState // 原格式的弹道状态
	lastN []laneState // 昵称头像版的弹道状态
}

// 返回昵称头像版 ASS 和 jsonl 的文件路径
func nickJsonlFile(assFile string) (string, string) {
	base := strings.TrimSuffix(assFile, ".ass")
	return base + ".nick.ass", base + ".jsonl"
}

// 创建弹幕写入器，覆盖写文件头，重启续录时沿用同一个写入器即可
func newDanmuWriter(liveID, streamName string, cfg acfundanmu.SubConfig, assFile string) *danmuWriter {
	nickFile, jsonlFile := nickJsonlFile(assFile)
	w := &danmuWriter{
		cfg:   cfg,
		lastO: make([]laneState, laneNum),
		lastN: make([]laneState, laneNum),
	}
	var err error
	w.ass, err = os.OpenFile(assFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	checkErr(err)
	w.nick, err = os.OpenFile(nickFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	checkErr(err)
	w.jsonl, err = os.OpenFile(jsonlFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	checkErr(err)

	fmt.Fprintf(w.ass, scriptInfoTmpl, liveID, streamName, cfg.Title, cfg.PlayResX, cfg.PlayResY)
	fmt.Fprintf(w.ass, stylesTmpl, cfg.FontSize)
	fmt.Fprint(w.ass, eventsTmpl)
	fmt.Fprintf(w.nick, scriptInfoTmpl, liveID, streamName, cfg.Title+" 昵称头像版", cfg.PlayResX, cfg.PlayResY)
	fmt.Fprintf(w.nick, stylesTmpl, cfg.FontSize)
	fmt.Fprint(w.nick, eventsTmpl)

	meta, err := json.Marshal(danmuMeta{PlayResX: cfg.PlayResX, PlayResY: cfg.PlayResY, FontSize: cfg.FontSize, StartTime: cfg.StartTime})
	checkErr(err)
	w.jsonl.Write(meta)
	w.jsonl.Write([]byte("\n"))
	return w
}

// 写入一条弹幕
func (w *danmuWriter) write(c *acfundanmu.Comment) {
	s := w.cfg
	sendTime := c.SendTime * 1e6
	rel := sendTime - s.StartTime

	// 原格式 ASS，碰撞避让和坐标公式与 acfundanmu 完全一致
	length := utf8.RuneCountInString(c.Content) * s.FontSize
	dtO := laneState{
		appear:    rel,
		emerge:    rel + (int64(length)*danmuShowDur)/int64(s.PlayResX+length),
		disappear: rel + danmuShowDur,
	}
	leftO := rel + (int64(s.PlayResX)*danmuShowDur)/int64(s.PlayResX+length)
	if i := placeLane(w.lastO, dtO, leftO); i >= 0 {
		fmt.Fprintf(w.ass, dialogueTmpl,
			assTime(dtO.appear), assTime(dtO.disappear),
			strings.ReplaceAll(c.Nickname, ",", " "), c.UserID,
			s.PlayResX+length/2, s.FontSize*(i+1), -length/2, s.FontSize*(i+1), c.Content)
	}

	// 昵称头像版 ASS，\an7 锚点在文本左上角，头像由 ffmpeg 叠在文字左侧，不依赖字体渲染宽度
	text := c.Nickname + "(" + strconv.FormatInt(c.UserID, 10) + "):" + c.Content
	width := textWidth(text, s.FontSize)
	avW, avGap := avatarSize(s.FontSize), avatarGap(s.FontSize)
	total := avW + avGap + width // 头像、间隔和文字的总宽度
	dtN := laneState{
		appear:    rel,
		emerge:    rel + (int64(total)*danmuShowDur)/int64(s.PlayResX+total),
		disappear: rel + danmuShowDur,
	}
	leftN := rel + (int64(s.PlayResX)*danmuShowDur)/int64(s.PlayResX+total)
	if i := placeLane(w.lastN, dtN, leftN); i >= 0 {
		fmt.Fprintf(w.nick, dialogueNickTmpl,
			assTime(dtN.appear), assTime(dtN.disappear),
			strings.ReplaceAll(c.Nickname, ",", " "), c.UserID,
			s.PlayResX+avW+avGap, s.FontSize*i, -width, s.FontSize*i, text)
		rec := danmuRecord{
			Time:    float64(rel) / 1e9,
			UID:     c.UserID,
			Name:    c.Nickname,
			Avatar:  c.Avatar,
			Content: c.Content,
			Lane:    i,
			Width:   width,
		}
		b, err := json.Marshal(rec)
		checkErr(err)
		w.jsonl.Write(b)
		w.jsonl.Write([]byte("\n"))
	}
}

// 消费弹幕队列直到结束，返回说明队列已结束（出错或主播下播）
func (w *danmuWriter) consume(ctx context.Context, ac *acfundanmu.AcFunLive) {
	for {
		select {
		case <-ctx.Done():
			return
		default:
			danmu := ac.GetDanmu()
			if danmu == nil {
				return
			}
			for _, d := range danmu {
				if c, ok := d.(*acfundanmu.Comment); ok {
					w.write(c)
				}
			}
		}
	}
}

// 关闭所有文件
func (w *danmuWriter) close() {
	w.ass.Close()
	w.nick.Close()
	w.jsonl.Close()
}

// ==================== 录制流程 ====================

// 录制直播弹幕
func (s streamer) getDanmu(ctx context.Context, info liveInfo) {
	defer func() {
		if err := recover(); err != nil {
			lPrintErr("Recovering from panic in getDanmu(), the error is:", err)
			lPrintErrf("录制%s的直播弹幕发生错误，如要重启录制，请运行 startdanmu %d", s.longID(), s.UID)
		}
	}()

	lPrintln("开始录制" + s.longID() + "的直播弹幕")
	lPrintln("本次录制的 ass 文件保存在" + info.assFile)
	lPrintf("如果想提前结束录制%s的直播弹幕，运行 stopdanmu %d", s.longID(), s.UID)

	defer s.moveDanmuFiles(info.assFile)

	ac, err := acfundanmu.NewAcFunLive(acfundanmu.SetLiverUID(int64(s.UID)))
	checkErr(err)
	_ = ac.StartDanmu(ctx, false)
	streamInfo := ac.GetStreamInfo()
	w := newDanmuWriter(streamInfo.LiveID, streamInfo.StreamName, info.cfg, info.assFile)
	defer w.close()
	w.consume(ctx, ac)

	// 断流后先观察一个窗口：网络波动或主播短暂掉线（20 秒内）恢复时沿用同一个写入器接着写，
	// 弹幕时间轴和视频分段保持一致，最终和视频一起合成同一个成片
	fails := 0
	for {
		markResumeWait(info.LiveID)
		resumed := s.waitResume(ctx)
		clearResumeWait(info.LiveID)
		if !resumed {
			break
		}
		if fails >= maxResumeRetry {
			lPrintWarnf("重连%s的直播弹幕连续失败 %d 次，结束本场弹幕录制", s.longID(), fails)
			break
		}
		lPrintWarn("因意外结束录制" + s.longID() + "的直播弹幕，尝试重启录制")
		begin := time.Now()
		ac, err := acfundanmu.NewAcFunLive(acfundanmu.SetLiverUID(int64(s.UID)))
		if err != nil {
			lPrintErrf("重连%s的直播弹幕失败：%v", s.longID(), err)
			fails++
			time.Sleep(time.Second)
			continue
		}
		_ = ac.StartDanmu(ctx, false)
		w.consume(ctx, ac)
		// 连上几秒就断开说明这次重连没成功，计数避免一直高频重连
		if time.Since(begin) < 5*time.Second {
			fails++
		} else {
			fails = 0
		}
		time.Sleep(5 * time.Second)
	}

	lPrintln(s.longID() + "的直播弹幕录制已经结束")
}

// 退出直播弹幕录制相关操作
func (s streamer) quitDanmu(liveID string) {
	finishDanmuPart(liveID)
}

// 初始化弹幕录制
func (s streamer) initDanmu(ctx context.Context, liveID, filename string) {
	dctx, dcancel := context.WithCancel(ctx)
	defer dcancel()
	if info, ok := getLiveInfo(liveID); ok && info.isDanmu {
		lPrintWarnf("已经在录制%s的直播弹幕，如要重启录制，请先运行 stopdanmu %d", s.longID(), s.UID)
		return
	}

	// 获取弹幕字幕设置
	cfg, err := s.getSubConfig()
	if err != nil {
		lPrintErr(err)
		lPrintErrf("无法获取%s的直播源，退出录制直播弹幕，请确定主播正在直播，如要重启录制直播弹幕，请运行 startdanmu %d", s.longID(), s.UID)
		return
	}

	info := liveInfo{LiveID: liveID, uid: s.UID, cfg: cfg}

	assFile := transFilename(filename)
	if assFile == "" {
		return
	}
	info.assFile = assFile + ".ass"
	info.cfg.Title = filepath.Base(assFile)
	info.cfg.StartTime = time.Now().UnixNano()
	info.isDanmu = true
	info.danmuCancel = dcancel
	updateLiveInfo(liveID, func(i *liveInfo) {
		i.uid = info.uid
		i.isDanmu = true
		i.danmuStarted = true
		i.danmuCancel = info.danmuCancel
		i.assFile = info.assFile
		i.cfg = info.cfg
	})
	defer s.quitDanmu(info.LiveID)

	s.getDanmu(dctx, info)
}

// 临时录制指定主播的直播弹幕
func startDanmu(uid int) bool {
	s, ok := getStreamer(uid)
	if !ok {
		name := getName(uid)
		if name == "" {
			lPrintWarnf("不存在 uid 为%d的用户", uid)
			return false
		}
		s = streamer{UID: uid, Name: name}
	}

	liveID := getLiveID(uid)
	if liveID == "" {
		lPrintErr(s.longID() + "不在直播，取消录制直播弹幕")
		return false
	}
	if isDanmu(liveID) {
		lPrintWarnf("已经在录制%s的直播弹幕，如要重启录制，请先运行 stopdanmu %d", s.longID(), s.UID)
		return false
	}

	filename := getTime() + " " + s.Name + " " + s.getTitle()

	// goroutine 是为了快速返回
	safeGo(s.longID()+"的弹幕录制", func() { s.initDanmu(mainCtx, liveID, filename) })
	return true
}

// 停止录制指定主播的直播弹幕
func stopDanmu(uid int) bool {
	infoList, ok := getLiveInfoByUID(uid)
	if !ok {
		lPrintWarnf("没有在录制 uid 为%d的主播的直播弹幕", uid)
		return true
	}

	for _, info := range infoList {
		if info.isDanmu {
			lPrintf("开始停止录制%s的liveID为%s直播弹幕", longID(uid), info.LiveID)
			updateLiveInfo(info.LiveID, func(i *liveInfo) { i.danmuStopped = true })
			info.danmuCancel()
		}
	}

	return true
}