package routes

import (
	"game-driver/internal/middleware"
	"game-driver/internal/schema"
	"game-driver/leaf"
	"game-driver/pkg/audio"
	"game-driver/pkg/logger"
	"game-driver/pkg/relay"
	"game-driver/pkg/tts"
	"game-driver/pkg/utils"
	"game-driver/pkg/video"
	"github.com/gopxl/beep/v2/speaker"
	"sync"
	"time"
)

func timerAction(timestamp int64) <-chan struct{} {
	a := make(chan struct{})

	go func() {
		if timestamp == 0 {
			close(a)
		} else {
			<-time.After(time.Until(time.Unix(timestamp, 0)))
			close(a)
		}
	}()

	return a
}

func WaitAction(c *leaf.Context) {
	payload := leaf.Value[*schema.WaitModel](c, middleware.PayloadJSONKey)

	if payload.Start != 0 && payload.End != 0 && time.Unix(payload.Start, 0).After(time.Unix(payload.End, 0)) {
		logger.Infoln("开始时间大于结束时间")
		return
	}

	if payload.End != 0 {
		cancel := leaf.WithDeadline(c, time.Unix(payload.End, 0))
		defer cancel()
	}

	select {
	case <-c.Done():
	case <-timerAction(payload.Start):
		// 等待组
		var wait sync.WaitGroup
		defer wait.Wait()
		for _, item := range payload.Items {
			switch item.Type {
			case schema.WaitAudio:
				// 执行音乐播放
				wait.Add(1)
				go func() {
					defer wait.Done()
					audioAction(c, item, payload.TimeModel)
				}()
			case schema.WaitTTS:
				// 执行TTS播放
				wait.Add(1)
				go func() {
					defer wait.Done()
					ttsAction(c, item, payload.TimeModel)
				}()
			case schema.WaitRelay:
				// 执行继电器供电
				wait.Add(1)
				go func() {
					defer wait.Done()
					relayAction(c, item, payload.TimeModel)
				}()
			case schema.WaitVideo:
				// 执行视频播放
				wait.Add(1)
				go func() {
					defer wait.Done()
					videoAction(c, item, payload.TimeModel)
				}()
			case schema.WaitWeb:
			default:
				logger.Infof("不支持的类型: %d\n", item.Type)
			}
		}
	}
}

func audioAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
		logger.Infoln("开始时间小于根任务开始时间")
		return
	}

	if item.End != 0 {
		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
		defer cancel()
	}

	data, err := utils.LinkAudio(item.Data)
	if err != nil {
		logger.Errorln("音频数据获取异常: ", err)
		return
	}

	select {
	case <-c.Done():
	case <-timerAction(item.Start):
		{
			logger.Infoln("播放待机音乐")
			defer logger.Infoln("结束待机音乐")

			ctrl, closer, e := audio.PlayBgmMP3(data)
			defer closer()
			if e != nil {
				logger.Errorln("播放待机音乐异常", e)
				return
			}

			select {
			case <-c.Done():
				{
					speaker.Lock()
					ctrl.Streamer = nil
					speaker.Unlock()
				}
			}
		}
	}
}

func ttsAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
		logger.Infoln("开始时间小于根任务开始时间")
		return
	}

	if item.End != 0 {
		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
		defer cancel()
	}

	reader, err := tts.DefaultTTS.Get(item.Data)
	if err != nil {
		logger.Errorln("语音合成异常: ", err)
		return
	}

	select {
	case <-c.Done():
	case <-timerAction(item.Start):
		{
			logger.Infoln("循环播放待机 TTS 语音")
			defer logger.Infoln("结束待机 TTS 语音")

			for {
				audio.PlayWav(c, reader)
				select {
				case <-c.Done():
					return
				case <-time.After(time.Duration(item.Interval) * time.Second):
				}
			}
		}
	}
}

func relayAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
		logger.Infoln("开始时间小于根任务开始时间")
		return
	}

	if item.End != 0 {
		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
		defer cancel()
	}

	device, err := relay.New(item.Data, nil)
	if err != nil {
		logger.Errorln("继电器初始化异常: ", err)
		return
	}
	defer device.Close()

	select {
	case <-c.Done():
	case <-timerAction(item.Start):
		{
			logger.Infoln("待机继电器供电")
			defer logger.Infoln("待机继电器断电")

			device.On(1)
			<-c.Done()
			device.Off(1)
		}
	}
}

func videoAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
		logger.Infoln("开始时间小于根任务开始时间")
		return
	}

	if item.End != 0 {
		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
		defer cancel()
	}

	local, err := utils.LinkVideo(item.Data)
	if err != nil {
		logger.Errorln("视频文件获取异常: ", err)
		return
	}

	select {
	case <-c.Done():
	case <-timerAction(item.Start):
		{
			logger.Infoln("循环播放待机视频")
			defer logger.Infoln("结束待机视频")

			utils.BlankOpen()
			defer utils.BlankClose()

			for {
				err := video.Play(c, local)
				if err != nil {
					logger.Infof("视频播放异常: %s", err)
					return
				}
				select {
				case <-c.Done():
					return
				case <-time.After(time.Duration(item.Interval) * time.Second):
				}
			}
		}
	}
}