package web

import (
	"context"
	"fmt"
	"log/slog"
	_ "net/http/pprof"
	"platform/web/events"
	base "platform/web/globals"
	"platform/web/tasks"
	"time"

	"github.com/gofiber/fiber/v2"
	"github.com/hibiken/asynq"
	"golang.org/x/sync/errgroup"
)

func RunApp(pCtx context.Context) error {
	g, ctx := errgroup.WithContext(pCtx)

	// 初始化依赖
	err := base.Init(ctx)
	if err != nil {
		return fmt.Errorf("初始化依赖失败: %w", err)
	}

	// 运行服务
	g.Go(func() error {
		return RunWeb(ctx)
	})

	g.Go(func() error {
		return RunTask(ctx)
	})

	g.Go(func() error {
		return RunSchedule(ctx)
	})

	return g.Wait()
}

func RunWeb(ctx context.Context) error {

	fiber := fiber.New(fiber.Config{
		ProxyHeader:  fiber.HeaderXForwardedFor,
		ErrorHandler: ErrorHandler,
	})

	ApplyMiddlewares(fiber)
	ApplyRouters(fiber)

	// 停止服务
	go func() {
		<-ctx.Done()
		err := fiber.Shutdown()
		if err != nil {
			slog.Error("服务停止失败", "error", err)
		}
	}()

	// 启动服务
	slog.Info("web 服务开始监听 :8080")
	err := fiber.Listen("0.0.0.0:8080")
	if err != nil {
		return fmt.Errorf("web 服务监听失败: %w", err)
	}

	slog.Info("web 服务已停止")
	return nil
}

func RunSchedule(ctx context.Context) error {
	var scheduler = asynq.NewSchedulerFromRedisClient(base.Redis, &asynq.SchedulerOpts{
		Location: time.Local,
	})

	scheduler.Register("* * * * *", events.NewFlushGateway())

	// 停止服务
	go func() {
		<-ctx.Done()
		scheduler.Shutdown()
	}()

	// 启动服务
	err := scheduler.Run()
	if err != nil {
		return fmt.Errorf("调度服务运行失败: %w", err)
	}

	return nil
}

func RunTask(ctx context.Context) error {
	var server = asynq.NewServerFromRedisClient(base.Redis, asynq.Config{})

	var mux = asynq.NewServeMux()
	mux.HandleFunc(events.RemoveChannel, tasks.HandleRemoveChannel)
	mux.HandleFunc(events.CancelTrade, tasks.HandleCancelTrade)
	mux.HandleFunc(events.FlushGateway, tasks.HandleFlushGateway)

	// 停止服务
	go func() {
		<-ctx.Done()
		server.Shutdown()
	}()

	// 启动服务
	err := server.Run(mux)
	if err != nil {
		return fmt.Errorf("任务服务运行失败: %w", err)
	}

	return nil
}