package router

import (
	"github.com/gin-contrib/cors"
	"github.com/gin-gonic/gin"
	log "github.com/sirupsen/logrus"
	swaggerFiles "github.com/swaggo/files"
	ginSwagger "github.com/swaggo/gin-swagger"
	"merch-parser-api/internal/interfaces"
	"merch-parser-api/internal/shared"
	"net/http"
	"time"
)

type router struct {
	apiPrefix         string
	engine            *gin.Engine
	ginMode           string
	excludeRoutes     map[string]shared.ExcludeRoute
	tokenProv         interfaces.JWTProvider
	usersRefreshRoute string
}

type Deps struct {
	ApiPrefix         string
	GinMode           string
	TokenProv         interfaces.JWTProvider
	UsersRefreshRoute string
}

func NewRouter(deps Deps) interfaces.Router {
	engine := gin.Default()

	if deps.GinMode == "release" {
		gin.SetMode(gin.ReleaseMode)
		err := engine.SetTrustedProxies([]string{"172.20.0.0/16"})
		if err != nil {
			log.WithError(err).Error("Router | Set proxies failed")
			return nil
		}
	}

	engine.Use(cors.New(cors.Config{
		AllowOrigins:     []string{"http://localhost:5173"},
		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
		AllowHeaders:     []string{"Origin", "Content-Type", "Authorization"},
		ExposeHeaders:    []string{"Content-Length"},
		AllowCredentials: true,
		MaxAge:           12 * time.Hour,
	}))

	return &router{
		apiPrefix:         deps.ApiPrefix,
		engine:            engine,
		tokenProv:         deps.TokenProv,
		usersRefreshRoute: deps.UsersRefreshRoute,
	}
}

func (r *router) Set() *gin.Engine {
	r.engine.NoRoute(func(c *gin.Context) {
		c.Status(http.StatusForbidden)
	})

	//version
	r.engine.GET("/version", func(c *gin.Context) { c.JSON(200, gin.H{"version": "2.0.0-alpha"}) })

	//swagger
	r.engine.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))

	r.engine.Use(authMiddleware(mwDeps{
		prefix:            r.apiPrefix,
		excludeRoutes:     &r.excludeRoutes,
		tokenProv:         r.tokenProv,
		usersRefreshRoute: r.usersRefreshRoute,
	}))

	return r.engine
}

func (r *router) ExcludeRoutes(routes []shared.ExcludeRoute) {
	log.Debug("Excluded routes:")
	excludedRoutes := make(map[string]shared.ExcludeRoute, len(routes))

	for _, route := range routes {
		log.Debugf("%s %s", route.Method, route.Route)
		ex := joinPaths(r.apiPrefix, route.Route)
		excludedRoutes[ex] = shared.ExcludeRoute{Route: ex, Method: route.Method}
	}
	r.excludeRoutes = excludedRoutes
}