package server

import (
    "context"
    "fmt"
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/rs/zerolog/log"
    "tss-rocks-be/ent"
    "tss-rocks-be/internal/config"
    "tss-rocks-be/internal/handler"
    "tss-rocks-be/internal/middleware"
    "tss-rocks-be/internal/service"
    "tss-rocks-be/internal/storage"
)

type Server struct {
    config  *config.Config
    router  *gin.Engine
    handler *handler.Handler
    server  *http.Server
}

func New(cfg *config.Config, client *ent.Client) (*Server, error) {
    // Initialize storage
    store, err := storage.NewStorage(context.Background(), &cfg.Storage)
    if err != nil {
        return nil, fmt.Errorf("failed to initialize storage: %w", err)
    }

    // Initialize service
    svc := service.NewService(client, store)

    // Initialize RBAC
    if err := svc.InitializeRBAC(context.Background()); err != nil {
        return nil, fmt.Errorf("failed to initialize RBAC: %w", err)
    }

    // Initialize handler
    h := handler.NewHandler(cfg, svc)

    // Initialize router
    router := gin.Default()

    // Add CORS middleware if needed
    router.Use(middleware.CORS())

    // 添加全局中间件
    router.Use(gin.Logger())
    router.Use(gin.Recovery())
    router.Use(middleware.RateLimit(&cfg.RateLimit))

    // 添加访问日志中间件
    accessLog, err := middleware.AccessLog(&cfg.AccessLog)
    if err != nil {
        return nil, fmt.Errorf("failed to initialize access log: %w", err)
    }
    router.Use(accessLog)

    // 为上传路由添加文件验证中间件
    router.POST("/api/v1/media/upload", middleware.ValidateUpload(&cfg.Storage.Upload))

    // Register routes
    h.RegisterRoutes(router)

    return &Server{
        config:  cfg,
        router:  router,
        handler: h,
    }, nil
}

func (s *Server) Start() error {
    addr := fmt.Sprintf("%s:%d", s.config.Server.Host, s.config.Server.Port)
    s.server = &http.Server{
        Addr:    addr,
        Handler: s.router,
    }

    log.Info().Msgf("Starting server on %s", addr)
    return s.server.ListenAndServe()
}

func (s *Server) Shutdown(ctx context.Context) error {
    if s.server != nil {
        return s.server.Shutdown(ctx)
    }
    return nil
}