package main

import (
	"91porn-server/common/cachev2"
	"91porn-server/common/dataReport"
	"context"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"91porn-server/common"
	"91porn-server/common/conf"
	"91porn-server/common/db"
	"91porn-server/common/laosiji"
	"91porn-server/common/log"
	recommendqueue "91porn-server/common/shortrecommend"
	"91porn-server/common/tg"
	"91porn-server/models"
	"91porn-server/models/Init"
	"91porn-server/skd/job"
	"91porn-server/skd/service"
	"91porn-server/skd/skdg"
)

func init() {
	cfg := skdg.GlobalConfig{}
	log.Info("load config start...")
	if err := conf.LoadJSON("config/skd.json", &cfg); err != nil {
		log.Error("startUp get config error: %v", log.E(err))
		panic(err)
	}
	skdg.Conf = &cfg
	log.Info("load config end..")
	log.Init(log.Options{Level: skdg.Conf.Log.Level})
	log.Info("daichong conf Domain", log.Any("donmain", skdg.Conf.DaiChong.Domain))
}

var httpServer *http.Server

func main() {
	time.Local, _ = time.LoadLocation("Asia/Shanghai")
	common.Go(func() {
		startUp()
		httpServerStart()
		job.Start()
	})
	waitQuit()
}

func startUp() {
	if skdg.Conf.Base.Env == "prod" {
		skdg.Bot = tg.New(tg.TianTian_Bot, fmt.Sprintf("短视频[env:%s][Skd-Server]", skdg.Conf.Base.Env))
		common.SetPanicHandler(func(s string) {
			_ = skdg.Bot.Send(tg.Msg{ChatId: tg.ChatIdServerTeam, Text: `\[SKD-Server\]` + s})
		})
	}
	ds := db.InitDS(initMongodbParam(models.RegisterPool))
	if len(ds) > 0 {
		for k, v := range ds {
			switch k {
			case models.VideoDb:
				skdg.VideoDB = v
			case models.LogDb:
				skdg.LogDB = v
			case models.StatDb:
				skdg.StatDB = v
			}
		}
	}
	dataReport.Init(dataReport.Config{
		ApiUrl: skdg.Conf.DataReport.Url,
	})
	laosiji.InitConfig(laosiji.Config{
		AppID:     skdg.Conf.LSJ.AppID,
		APIKey:    skdg.Conf.LSJ.APIKey,
		APIUrl:    skdg.Conf.LSJ.APIUrl,
		ImageYuan: skdg.Conf.LSJ.ImageYuan,
		NoticeURL: skdg.Conf.LSJ.NoticeURL,
	})
	skdg.InitRedis()
	if err := recommendqueue.SetKeyTTLHours(skdg.Conf.ShortRecommendKeyTTL()); err != nil {
		log.Error("short recommend key TTL config invalid, use default",
			log.E(err), log.Any("configuredHours", skdg.Conf.ShortRecommendKeyTTL()))
		_ = recommendqueue.SetKeyTTLHours(72)
	}
	// 初始化缓存操作中间件
	cachev2.Init(skdg.Redis, log.ZapLog)
	skdg.InitElastic()
	skdg.InitStatic()
	Init.InitMongo()
	Init.ESInit()
	if skdg.Conf.Switch.NotifyExpire {
		service.DoRegister()
	}
	// service.RobotPublishComment()
	// service.Init()
	// service.VideoInfo.FullUpdate()
}

func waitQuit() {
	//graceful exit
	ch := make(chan os.Signal, 1)
	signal.Notify(ch, syscall.SIGTERM, syscall.SIGQUIT, syscall.SIGINT)
	<-ch
	log.Info("Recv Signal, Shutdown Server Start...")
	log.Info("Pleace Wait Job Stop...")
	job.Stop()
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if httpServer != nil {
		if err := httpServer.Shutdown(ctx); err != nil {
			log.Error("Server Shutdown error", log.E(err))
		}
	}
	db.CloseDS()
	if err := skdg.RedisClose(); err != nil {
		log.Error("redis close error", log.E(err))
		return
	}
	log.Warn("Shutdown Server OK...")
}

func initMongodbParam(registerPool []models.Register) ([]db.DBmap, []db.Register) {
	pri := db.DBmap{
		Key: models.VideoDb,
		URL: skdg.Conf.Mongo.VideoDbUrl,
	}
	sta := db.DBmap{
		Key: models.StatDb,
		URL: skdg.Conf.Mongo.StatDbUrl,
	}
	log := db.DBmap{
		Key: models.LogDb,
		URL: skdg.Conf.Mongo.LogDbUrl,
	}
	dbgister := make([]db.Register, len(registerPool))
	for i, v := range registerPool {
		dbgister[i] = db.Register{Key: v.Key, Table: v.Table}
	}
	dbmaps := []db.DBmap{pri, sta, log}
	return dbmaps, dbgister
}

func httpServerStart() {
	common.Go(func() {
		//开始http
		port := skdg.Conf.Base.Port
		httpServer = &http.Server{
			Addr: fmt.Sprintf(":%d", port),
		}
		log.Info("Start Listen ...", log.Any("port", port))
		if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatal("server listen err", log.E(err))
		}
		// Block Here
		log.Info("httpServer quit...")
	})
}