package internal

import (
	"context"
	"fmt"
	"game-driver/config"
	"game-driver/internal/common"
	"game-driver/internal/middleware"
	"game-driver/internal/routes"
	"game-driver/internal/schema"
	"game-driver/leaf"
	"game-driver/pkg/logger"
	"game-driver/pkg/tts"
	"game-driver/pkg/utils"
	"github.com/eclipse/paho.golang/autopaho"
	"github.com/eclipse/paho.golang/paho"
	"go.uber.org/zap"
	"net/url"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func buildMqtt(c config.MqttConfig, r *leaf.Engine, subTopics ...string) autopaho.ClientConfig {
	u, err := url.Parse(c.Url)
	if err != nil {
		logger.Panicln("mqtt url parse error: ", err)
	}

	subscriptions := make([]paho.SubscribeOptions, 0)
	for _, topic := range subTopics {
		logger.Infoln("订阅主题: ", topic)
		subscriptions = append(subscriptions, paho.SubscribeOptions{Topic: topic, QoS: 0})
	}

	mqttConfig := autopaho.ClientConfig{
		ServerUrls:                    []*url.URL{u},
		KeepAlive:                     20,
		CleanStartOnInitialConnection: false,
		SessionExpiryInterval:         60,
		OnConnectionUp: func(cm *autopaho.ConnectionManager, _ *paho.Connack) {
			logger.Infoln("MQTT 连接成功")
			if _, err := cm.Subscribe(context.Background(), &paho.Subscribe{
				Subscriptions: subscriptions,
			}); err != nil {
				logger.Errorf("failed to subscribe (%s). This is likely to mean no messages will be received.", err)
				return
			}
			logger.Infoln("订阅完成")
		},
		OnConnectError: func(err error) {
			logger.Infof("MQTT 连接异常: %s\n", err)
		},
		ClientConfig: paho.ClientConfig{
			ClientID: "TestSubscriber",
			OnPublishReceived: []func(paho.PublishReceived) (bool, error){
				func(pr paho.PublishReceived) (bool, error) {
					r.Route(pr.Packet.Packet())
					return true, nil
				},
			},
			OnClientError: func(err error) { logger.Errorf("client error: %s\n", err) },
			OnServerDisconnect: func(d *paho.Disconnect) {
				if d.Properties != nil {
					logger.Warnf("server requested disconnect: %s\n", d.Properties.ReasonString)
				} else {
					logger.Warnf("server requested disconnect; reason code: %d\n", d.ReasonCode)
				}
			},
		},
	}

	return mqttConfig
}

func Run() {
	topicPrefix := fmt.Sprintf("server/%s/%v/", config.C.Location, config.C.Point)
	publishTopic := fmt.Sprintf("device/%s/%v/status", config.C.Location, config.C.Point)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	router := leaf.Default(ctx)
	// 应用推出时刷新所有缓冲日志
	defer logger.DefaultLogger.Sync()

	log, _ := zap.NewStdLogAt(logger.DefaultLogger.ZapLogger(), zap.DebugLevel)
	router.SetDebugLogger(log)

	router.DefaultHandler(func(c *leaf.Context) {
		logger.Infof("未处理消息，topic: %s\n payload: %s\n", c.Topic, c.Payload)
	})

	// 构建 MQTT 连接
	mqttBuild := buildMqtt(config.C.Mqtt, router, topicPrefix+"#")

	// 连接 MQTT
	cm, err := autopaho.NewConnection(ctx, mqttBuild)
	if err != nil {
		logger.Panicln("连接 MQTT 异常: ", err)
	}

	// 构建语音合成对象
	tts.DefaultTTS = tts.New(ctx, config.C.Aliyun)

	// 构建继电器对象
	//r, err := relay.New(config.C.Relay, func(msg string) {
	//	logger.Infoln("串口返回: ", msg)
	//})
	//if err != nil {
	//	logger.Panicln("串口连接异常: ", err)
	//}
	//defer r.Close()

	// 构建全局设备变量
	device := common.DefaultDevice(ctx, cm, publishTopic)
	// 设备状态变化
	device.OnChange = func() { device.PublishStatus() }

	// 处理启动报文
	router.RegisterHandler(topicPrefix+"play",
		middleware.RunLog(),
		middleware.PayloadJSON[schema.PlayModal](),
		middleware.DeviceLock(device),
		middleware.EmergencyStop(common.GlobalStopper),
		middleware.SoundStart(),
		middleware.RelayMaster(nil),
		middleware.TimeoutOver(config.C.Game.MaxTimeout),
		middleware.TickerAction(),
		middleware.PlayBgm(),
		routes.PlayRouter(config.C.Location, config.C.Point),
	)
	// 处理待机报文
	router.RegisterHandler(topicPrefix+"wait",
		middleware.RunLog(),
		middleware.PayloadJSON[schema.WaitModel](),
		middleware.Unique(common.GlobalBgStopper),
		middleware.EmergencyStop(common.GlobalBgStopper),
		routes.WaitAction,
	)
	// 处理指令
	router.RegisterHandler(topicPrefix+"command",
		middleware.RunLog(),
		routes.Command(device),
	)

	// 启动完成发送一次设备状态
	device.PublishStatus()
	// 启动完成关闭屏幕
	utils.BlankClose()

	sig := make(chan os.Signal, 1)
	signal.Notify(sig, os.Interrupt, syscall.SIGTERM)

	<-sig
	logger.Infoln("接收到关闭命令 - 正在关闭程序")

	ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if e := cm.Disconnect(ctx); e != nil {
		logger.Errorln("断开连接异常", e)
	}

	logger.Infoln("关闭完成")
}