package main

import (
	"context"
	"errors"
	"log"
	"net/http"
	"os/signal"
	"syscall"
	"time"
	_ "time/tzdata"

	"chatapp3-golang/internal/bootstrap"
	"chatapp3-golang/internal/router"
	"chatapp3-golang/internal/service/apppopup"
	"chatapp3-golang/internal/service/baishun"
	"chatapp3-golang/internal/service/binancerecharge"
	"chatapp3-golang/internal/service/errorlog"
	"chatapp3-golang/internal/service/gameopen"
	"chatapp3-golang/internal/service/gameprovider"
	"chatapp3-golang/internal/service/hostcenter"
	"chatapp3-golang/internal/service/invite"
	"chatapp3-golang/internal/service/lingxian"
	"chatapp3-golang/internal/service/luckygift"
	"chatapp3-golang/internal/service/managercenter"
	"chatapp3-golang/internal/service/propsstore"
	"chatapp3-golang/internal/service/rechargeagency"
	"chatapp3-golang/internal/service/rechargereward"
	"chatapp3-golang/internal/service/regionimgroup"
	"chatapp3-golang/internal/service/registerreward"
	"chatapp3-golang/internal/service/roomturnoverreward"
	"chatapp3-golang/internal/service/signinreward"
	"chatapp3-golang/internal/service/smashegg"
	"chatapp3-golang/internal/service/taskcenter"
	"chatapp3-golang/internal/service/userbadge"
	"chatapp3-golang/internal/service/vip"
	"chatapp3-golang/internal/service/voiceroomredpacket"
	"chatapp3-golang/internal/service/voiceroomrocket"
	"chatapp3-golang/internal/service/weekstar"
	"chatapp3-golang/internal/service/wheel"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	app, err := bootstrap.New(ctx)
	if err != nil {
		log.Fatalf("bootstrap api failed: %v", err)
	}

	appPopupService := apppopup.NewService(app.Config, app.Repository.DB, app.Repository.Redis)
	errorLogService := errorlog.NewService(app.Repository.DB)
	inviteService := invite.NewInviteService(app.Config, app.Repository.DB, app.Repository.Redis, &app.Gateways)
	baishunService := baishun.NewBaishunService(app.Config, app.Repository.DB, app.Repository.Redis, &app.Gateways)
	binanceRechargeService := binancerecharge.NewService(app.Config, app.Repository.DB, &app.Gateways)
	lingxianService := lingxian.NewService(app.Config, app.Repository.DB, app.Repository.Redis)
	gameOpenService := gameopen.NewGameOpenService(app.Config, app.Repository.DB, &app.Gateways)
	luckyGiftService := luckygift.NewLuckyGiftService(app.Config, app.Repository.DB, app.Repository.Redis, app.Gateways.Wallet)
	rechargeAgencyService := rechargeagency.NewService(app.Config, app.Repository.DB, &app.Gateways)
	registerRewardService := registerreward.NewRegisterRewardService(app.Config, app.Repository.DB, app.Repository.Redis, &app.Gateways)
	rechargeRewardService := rechargereward.NewService(app.Config, app.Repository.DB, &app.Gateways)
	signInRewardService := signinreward.NewSignInRewardService(app.Config, app.Repository.DB, app.Repository.Redis, &app.Gateways)
	taskCenterService := taskcenter.NewService(app.Config, app.Repository.DB, &app.Gateways)
	userBadgeService := userbadge.NewService(app.Repository.DB)
	vipService := vip.NewService(app.Config, app.Repository.DB, &app.Gateways)
	wheelService := wheel.NewService(app.Config, app.Repository.DB, &app.Gateways)
	smashEggService := smashegg.NewService(app.Config, app.Repository.DB, &app.Gateways)
	regionIMGroupService := regionimgroup.NewService(app.Config, app.Repository.DB, &app.Gateways)
	voiceRoomRedPacketService := voiceroomredpacket.NewService(app.Config, app.Repository.DB, app.Repository.Redis, app.Gateways.Wallet, regionIMGroupService, app.Gateways.Room)
	voiceRoomRedPacketService.SetRegionResolver(&app.Gateways)
	voiceRoomRocketService := voiceroomrocket.NewService(app.Config, app.Repository.DB, app.Repository.Redis, &app.Gateways)
	voiceRoomRocketService.SetRegionBroadcaster(regionIMGroupService)
	weekStarService := weekstar.NewWeekStarService(app.Config, app.Repository.DB, app.Repository.Redis, &app.Gateways)
	roomTurnoverRewardService := roomturnoverreward.NewService(app.Config, app.Repository.DB, &app.Gateways)
	hostCenterService := hostcenter.NewService(app.Config, &app.Gateways)
	managerCenterService := managercenter.NewService(app.Repository.DB, &app.Gateways)
	propsStoreService := propsstore.NewService(app.Repository.DB, app.Repository.Redis)

	baishunService.SetTaskEventReporter(taskCenterService)
	gameOpenService.SetTaskEventReporter(taskCenterService)
	weekStarService.SetTaskEventReporter(taskCenterService)

	workerCtx, workerCancel := context.WithCancel(context.Background())
	defer workerCancel()
	if err := registerRewardService.Start(workerCtx); err != nil {
		log.Fatalf("start register reward consumer failed: %v", err)
	}
	if err := weekStarService.StartMessageConsumer(workerCtx); err != nil {
		log.Fatalf("start week star message consumer failed: %v", err)
	}
	if err := taskCenterService.StartMessageConsumer(workerCtx); err != nil {
		log.Fatalf("start task center message consumer failed: %v", err)
	}
	if err := voiceRoomRocketService.Start(workerCtx); err != nil {
		log.Fatalf("start voice room rocket workers failed: %v", err)
	}
	if err := taskCenterService.StartArchiveWorker(workerCtx); err != nil {
		log.Fatalf("start task center archive worker failed: %v", err)
	}
	voiceRoomRedPacketService.StartRefundWorker(workerCtx)

	gameProviders := gameprovider.NewRegistry(
		baishun.NewAppProvider(baishunService),
		lingxian.NewAppProvider(lingxianService),
	)
	engine := router.NewRouter(app.Config, app.Repository, &app.Gateways, router.Services{
		AppPopup:           appPopupService,
		ErrorLog:           errorLogService,
		Invite:             inviteService,
		Baishun:            baishunService,
		BinanceRecharge:    binanceRechargeService,
		Lingxian:           lingxianService,
		GameOpen:           gameOpenService,
		GameProviders:      gameProviders,
		LuckyGift:          luckyGiftService,
		ManagerCenter:      managerCenterService,
		PropsStore:         propsStoreService,
		HostCenter:         hostCenterService,
		RechargeAgency:     rechargeAgencyService,
		RechargeReward:     rechargeRewardService,
		RegionIMGroup:      regionIMGroupService,
		RegisterReward:     registerRewardService,
		RoomTurnoverReward: roomTurnoverRewardService,
		SignInReward:       signInRewardService,
		SmashEgg:           smashEggService,
		TaskCenter:         taskCenterService,
		UserBadge:          userBadgeService,
		VIP:                vipService,
		Wheel:              wheelService,
		VoiceRoomRedPacket: voiceRoomRedPacketService,
		VoiceRoomRocket:    voiceRoomRocketService,
		WeekStar:           weekStarService,
	})
	server := &http.Server{
		Addr:              app.Config.HTTP.ListenAddr,
		Handler:           engine,
		ReadHeaderTimeout: 10 * time.Second,
	}
	serverErrors := make(chan error, 1)
	go func() {
		log.Printf("chatapp3-golang api listening on %s", app.Config.HTTP.ListenAddr)
		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			serverErrors <- err
			return
		}
		serverErrors <- nil
	}()

	shutdownSignal, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	select {
	case err := <-serverErrors:
		if err != nil {
			log.Fatalf("run server failed: %v", err)
		}
		return
	case <-shutdownSignal.Done():
		log.Printf("shutdown signal received, draining http traffic")
		workerCancel()
	}

	shutdownCtx, cancelShutdown := context.WithTimeout(context.Background(), app.Config.HTTP.ShutdownTimeout)
	defer cancelShutdown()
	if err := server.Shutdown(shutdownCtx); err != nil {
		log.Printf("graceful shutdown failed: %v", err)
		if closeErr := server.Close(); closeErr != nil {
			log.Printf("force close failed: %v", closeErr)
		}
	}
	if err := <-serverErrors; err != nil {
		log.Fatalf("server exited with error during shutdown: %v", err)
	}
}