package router

import (
	"netina/database"
	"netina/middlewares"
	license_repository "netina/repositories/license"
	owner_repository "netina/repositories/owner"
	plan_repository "netina/repositories/plan"
	role_repository "netina/repositories/role"
	store_repository "netina/repositories/store"
	user_repository "netina/repositories/user"
	"netina/services"

	auth "netina/services/authentication"
	a "netina/services/authorization"

	"github.com/labstack/echo/v4"
)






func LoginRoutes(e *echo.Echo) {
	login := e.Group("/login")
	login.POST("/phonenumber" , auth.RequestCode)
	login.POST("/verifycode" , auth.Login)
}


func UploadFile(e *echo.Echo){
	upload := e.Group("/upload")
	upload.Use(middlewares.JWTMiddleware)
	upload.POST("/", services.Upload , a.AdminRole )
	
}

func PanelRoutes(e *echo.Echo){
	panel := e.Group("/panel")
	panel.Use(middlewares.JWTMiddleware)
	panel.GET("/" , services.UpdatePanel , a.AdminRole)
	
}


func UserRoutes(e *echo.Echo){
	db := database.Db()
	user := e.Group("/user")
	user.Use(middlewares.JWTMiddleware)
	userCommandRepo := &user_repository.UserCommandRepository{DB: &db}
    userQueryRepo := &user_repository.UserQueryRepository{DB: &db}
	userService := &services.UserService{
        CommandRepo: *userCommandRepo,
        QueryRepo:   *userQueryRepo,
    }

	user.POST("/" , userService.CreateUser , a.AdminRole)
	user.GET("/:id" , userService.GetUser)
	user.GET("/phonenumber" , userService.GetUserByPhoneNumber)
	user.PUT("/:id" , userService.UpdateUser , a.AdminRole)
	user.DELETE("/:id" , userService.RemoveUser,a.AdminRole)
}



func OwnerRoutes(e *echo.Echo) {
	db := database.Db()
	owner := e.Group("/owner")
	owner.Use(middlewares.JWTMiddleware)
	ownerCommandRepo := &owner_repository.OwnerCommandRepository{DB: &db}
    ownerQueryRepo := &owner_repository.OwnerQueryRepository{DB: &db}
	ownerService := &services.OwnerService{
        CommandRepo: *ownerCommandRepo,
        QueryRepo:   *ownerQueryRepo,
    }
	owner.POST("/",ownerService.CreateOwner,a.AdminRole)
	owner.GET("/:id" , ownerService.GetOwner)
	owner.PUT("/:id" , ownerService.UpdateOwner,a.AdminRole)
	owner.DELETE("/:id" , ownerService.RemoveOwner,a.AdminRole)
}

func LicenseRoutes(e *echo.Echo) {
	db := database.Db()
	license := e.Group("/license")
	license.Use(middlewares.JWTMiddleware)
	licenseCommandRepo := &license_repository.LicenseCommandRepository{DB: &db}
    licenseQueryRepo := &license_repository.LicenseQueryRepository{DB: &db}
	licenseService := &services.LicenseService{
        CommandRepo: *licenseCommandRepo,
        QueryRepo:   *licenseQueryRepo,
    }
	license.POST("/",licenseService.CreateLicense,a.AdminRole)
	license.GET("/:id" , licenseService.GetLicense)
	license.PUT("/:id" , licenseService.UpdateLicense,a.AdminRole)
	license.DELETE("/:id" , licenseService.RemoveLicense,a.AdminRole)
}



func PlanRoutes(e *echo.Echo) {
	db := database.Db()
	plan := e.Group("/plan")
	plan.Use(middlewares.JWTMiddleware)
	planCommandRepo := &plan_repository.PlanCommandRepository{DB: &db}
    planQueryRepo := &plan_repository.PlanQueryRepository{DB: &db}
	planService := &services.PlanService{
        CommandRepo: *planCommandRepo,
        QueryRepo:   *planQueryRepo,
    }
	plan.POST("/",planService.CreatePlan,a.AdminRole)
	plan.GET("/:id" , planService.GetPlan)
	plan.PUT("/:id" , planService.UpdatePlan,a.AdminRole)
	plan.DELETE("/:id" , planService.RemovePlan,a.AdminRole)
}



func StoreRoutes(e *echo.Echo) {
	db := database.Db()
	store := e.Group("/store")
	store.Use(middlewares.JWTMiddleware)
	storeCommandRepo := &store_repository.StoreCommandRepository{DB: &db}
    storeQueryRepo := &store_repository.StoreQueryRepository{DB: &db}
	storeService := &services.StoreService{
        CommandRepo: *storeCommandRepo,
        QueryRepo:   *storeQueryRepo,
    }
	store.POST("/",storeService.CreateStore,a.AdminRole)
	store.GET("/:id" , storeService.GetStore)
	store.GET("/owner/:id" , storeService.GetStoresList)
	store.GET("/expiredate/:id" , services.ExpireDate , a.AdminRole)
	store.PUT("/:id" , storeService.UpdateStore,a.AdminRole)
	store.DELETE("/:id" , storeService.RemoveStore,a.AdminRole)
}


func RoleRoutes(e *echo.Echo) {
	db := database.Db()
	role := e.Group("/role")
	role.Use(middlewares.JWTMiddleware)
	roleCommandRepo := &role_repository.RoleCommandRepository{DB: &db}
    roleQueryRepo := &role_repository.RoleQueryRepository{DB: &db}
	roleService := &services.RoleService{
        CommandRepo: *roleCommandRepo,
        QueryRepo:   *roleQueryRepo,
    }
	role.POST("/",roleService.CreateRole,a.AdminRole)
	role.GET("/:id" , roleService.GetRole)
	role.PUT("/:id" , roleService.UpdateRole,a.AdminRole)
	role.DELETE("/:id" , roleService.RemoveRole,a.AdminRole)
}