package main

import (
	"flag"
	"fmt"
	"os"
	"os/signal"
	"syscall"

	dubboclient "dubbo.apache.org/dubbo-go/v3/client"
	_ "dubbo.apache.org/dubbo-go/v3/imports"
	"dubbo.apache.org/dubbo-go/v3/protocol"
	"dubbo.apache.org/dubbo-go/v3/server"

	"github.com/topfans/backend/pkg/database"
	"github.com/topfans/backend/pkg/logger"
	pb "github.com/topfans/backend/pkg/proto/task"
	pbUser "github.com/topfans/backend/pkg/proto/user"
	"github.com/topfans/backend/services/taskService/client"
	"github.com/topfans/backend/services/taskService/config"
	"github.com/topfans/backend/services/taskService/model"
	"github.com/topfans/backend/services/taskService/provider"
	"github.com/topfans/backend/services/taskService/repository"
	"github.com/topfans/backend/services/taskService/service"
	"github.com/topfans/backend/services/taskService/worker"
)

var port = flag.Int("port", 20006, "Dubbo service port")

func main() {
	// 1. Init logger（必须最前）
	env := os.Getenv("ENV")
	if env == "" {
		env = "development"
	}
	if err := logger.Init(logger.Config{ServiceName: "task-service", Environment: env, LogLevel: os.Getenv("LOG_LEVEL")}); err != nil {
		panic(fmt.Sprintf("Failed to init logger: %v", err))
	}
	defer logger.Sync()
	logger.Logger.Info("Starting taskService...")

	// 2. Init config（读取 flags/env）
	config.InitConfig()

	// 3. Init database + auto-migrate
	dbConfig := database.Config{
		Host:     config.DBConfig.Host,
		Port:     config.DBConfig.Port,
		User:     config.DBConfig.User,
		Password: config.DBConfig.Password,
		DBName:   config.DBConfig.DBName,
		SSLMode:  config.DBConfig.SSLMode,
		TimeZone: "Asia/Shanghai",
	}
	if err := database.Init(dbConfig); err != nil {
		logger.Logger.Fatal(fmt.Sprintf("Failed to init DB: %v", err))
	}
	db := database.GetDB()
	if err := db.AutoMigrate(
		&model.TaskDefinition{},
		&model.UserDailyTaskProgress{},
		&model.UserOnboardingProgress{},
		&model.UserOnboardingStatus{},
		&model.OnboardingStageConfig{},
		&model.ExhibitionRevenueRecord{},
		&model.TaskResetLog{},
	); err != nil {
		logger.Logger.Fatal(fmt.Sprintf("Failed to migrate tables: %v", err))
	}
	logger.Logger.Info("Database initialized")

	// 4. Init repositories
	dailyRepo := repository.NewDailyTaskRepository(db)
	onboardingRepo := repository.NewOnboardingRepository(db)
	revenueRepo := repository.NewRevenueRepository(db)
	logger.Logger.Info("Repositories initialized")

	// 5. Init userService Dubbo client + RPC client
	userCli, err := dubboclient.NewClient(
		dubboclient.WithClientURL(config.ServiceURLsConfig.UserService),
	)
	if err != nil {
		logger.Logger.Fatal(fmt.Sprintf("Failed to create userService client: %v", err))
	}
	userServiceClient, err := pbUser.NewUserSocialService(userCli)
	if err != nil {
		logger.Logger.Fatal(fmt.Sprintf("Failed to get userService: %v", err))
	}
	userRPCClient := client.NewUserServiceClient(userServiceClient)
	logger.Logger.Info("User RPC client initialized")

	// 6. Init services
	dailySvc := service.NewDailyTaskService(dailyRepo, userRPCClient)
	onboardingSvc := service.NewOnboardingService(onboardingRepo, dailyRepo, userRPCClient)
	revenueSvc := service.NewRevenueService(revenueRepo, userRPCClient)
	logger.Logger.Info("Services initialized")

	// 7. Init worker（goroutine 中启动）
	resetWorker := worker.NewDailyResetWorker(dailyRepo, revenueRepo, userRPCClient)
	go resetWorker.Start()
	logger.Logger.Info("Reset worker started")

	// 8. Init providers
	mobileProvider := provider.NewTaskMobileProvider(dailySvc, onboardingSvc, revenueSvc)
	internalProvider := provider.NewTaskInternalProvider(onboardingSvc, revenueSvc)
	logger.Logger.Info("Providers initialized")

	// 9. Create Dubbo server on port 20006
	srv, err := server.NewServer(
		server.WithServerProtocol(
			protocol.WithPort(*port),
			protocol.WithTriple(),
		),
	)
	if err != nil {
		logger.Logger.Fatal(fmt.Sprintf("Failed to create server: %v", err))
	}

	// 注册 Dubbo 服务
	if err := pb.RegisterTaskMobileServiceHandler(srv, mobileProvider); err != nil {
		logger.Logger.Fatal(fmt.Sprintf("Failed to register TaskMobileService: %v", err))
	}
	if err := pb.RegisterTaskInternalServiceHandler(srv, internalProvider); err != nil {
		logger.Logger.Fatal(fmt.Sprintf("Failed to register TaskInternalService: %v", err))
	}

	// 10. Start server (non-blocking)
	go func() {
		if err := srv.Serve(); err != nil {
			logger.Logger.Fatal(fmt.Sprintf("Failed to serve: %v", err))
		}
	}()
	logger.Logger.Info(fmt.Sprintf("taskService listening on port %d", *port))

	// Graceful shutdown
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	logger.Logger.Info("Shutting down taskService...")
	resetWorker.Stop()
}