package router

import (
	"github.com/iris-contrib/middleware/cors"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/mvc"
	"xps/bootstrap"
	"xps/service"
	"xps/web/controllers"
	"xps/web/middleware"
)

func Configure(b *bootstrap.Bootstrapper) {
	crs := cors.New(cors.Options{
		AllowedOrigins:   []string{"*"},
		AllowedMethods:   []string{"PUT", "PATCH", "GET", "POST", "OPTIONS", "DELETE"},
		AllowedHeaders:   []string{"*"},
		ExposedHeaders:   []string{"Accept", "Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization"},
		AllowCredentials: true,
	})

	// Static Resource
	b.HandleDir("/", "./public")

	// Login
	loginService := service.NewLoginService()
	loginApp := mvc.New(b.Party("/", crs).AllowMethods(iris.MethodOptions))
	loginApp.Register(loginService)
	loginApp.Handle(new(controllers.LoginController))

	// System
	sysParty := b.Party("/sys", crs).AllowMethods(iris.MethodOptions)
	{
		sysParty.Use(middleware.AuthToken)

		// Role
		roleService := service.NewRoleService()
		roleApp := mvc.New(sysParty.Party("/role"))
		roleApp.Register(roleService)
		roleApp.Handle(new(controllers.RoleController))

	}

	// Company Profile
	companyParty := b.Party("/company", crs).AllowMethods(iris.MethodOptions)
	{
		companyParty.Use(middleware.AuthToken)
		companyProfileService := service.NewCompanyProfileService()
		companyProfileApp := mvc.New(companyParty.Party("/profile"))
		companyProfileApp.Register(companyProfileService)
		companyProfileApp.Handle(new(controllers.CompanyProfileController))
	}

	// Group
	groupParty := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
	{
		groupParty.Use(middleware.AuthToken)
		groupService := service.NewGroupService()
		groupApp := mvc.New(groupParty.Party(""))
		groupApp.Register(groupService)
		groupApp.Handle(new(controllers.GroupController))
	}

	// User
	userParty := b.Party("/user", crs).AllowMethods(iris.MethodOptions)
	{
		userParty.Use(middleware.AuthToken)

		// user
		userService := service.NewUserService()
		userApp := mvc.New(userParty.Party(""))
		userApp.Register(userService)
		userApp.Handle(new(controllers.UserController))
	}
	
	// Position
	positionParty := b.Party("/position", crs).AllowMethods(iris.MethodOptions)
	{
		positionParty.Use(middleware.AuthToken)
		positionService := service.NewPositionService()
		positionApp := mvc.New(positionParty.Party(""))
		positionApp.Register(positionService)
		positionApp.Handle(new(controllers.PositionController))
	}

	// GroupCatParty
	GroupCatParty := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
	{
		GroupCatParty.Use(middleware.AuthToken)
		groupCatService := service.NewGroupCatService()
		groupCatApp := mvc.New(GroupCatParty.Party("/cat"))
		groupCatApp.Register(groupCatService)
		groupCatApp.Handle(new(controllers.GroupCatController))
	}

	// App
	appParty := b.Party("/app", crs).AllowMethods(iris.MethodOptions)
	{
		appParty.Use(middleware.AuthToken)
		appService := service.NewAppService()
		appApp := mvc.New(appParty.Party(""))
		appApp.Register(appService)
		appApp.Handle(new(controllers.AppController))

		appCatService := service.NewAppCatService()
		appCatApp := mvc.New(appParty.Party("/cat"))
		appCatApp.Register(appCatService)
		appCatApp.Handle(new(controllers.AppCatController))
		
		appPermitService := service.NewAppPermitService()
		appPermitApp := mvc.New(appParty.Party("/permit"))
		appPermitApp.Register(appPermitService)
		appPermitApp.Handle(new(controllers.AppPermitController))
	}

	// TaskCat
	taskCatParty := b.Party("/task", crs).AllowMethods(iris.MethodOptions)
	{
		taskCatParty.Use(middleware.AuthToken)
		taskCatService := service.NewTaskCatService()
		taskCatApp := mvc.New(taskCatParty.Party("/cat"))
		taskCatApp.Register(taskCatService)
		taskCatApp.Handle(new(controllers.TaskCatController))
	}

	// EntCat
	entCatParty := b.Party("/ent", crs).AllowMethods(iris.MethodOptions)
	{
		entCatParty.Use(middleware.AuthToken)
		entCatService := service.NewEntCatService()
		entCatApp := mvc.New(entCatParty.Party("/cat"))
		entCatApp.Register(entCatService)
		entCatApp.Handle(new(controllers.EntCatController))
	}

	// PartnerCat
	partnerCatParty := b.Party("/partner", crs).AllowMethods(iris.MethodOptions)
	{
		partnerCatParty.Use(middleware.AuthToken)
		partnerCatService := service.NewPartnerCatService()
		partnerCatApp := mvc.New(partnerCatParty.Party("/cat"))
		partnerCatApp.Register(partnerCatService)
		partnerCatApp.Handle(new(controllers.PartnerCatController))
	}

	// Model
	modelParty := b.Party("/model", crs).AllowMethods(iris.MethodOptions)
	{
		modelParty.Use(middleware.AuthToken)
		modelService := service.NewModelService()
		modelApp := mvc.New(modelParty.Party(""))
		modelApp.Register(modelService)
		modelApp.Handle(new(controllers.ModelController))

		modelObjectService := service.NewModelObjectService()
		modelObjectApp := mvc.New(modelParty.Party("/object"))
		modelObjectApp.Register(modelObjectService)
		modelObjectApp.Handle(new(controllers.ModelObjectController))
		
		modelObjectAttrService := service.NewModelObjectAttrService()
		modelObjectAttrApp := mvc.New(modelParty.Party("/object/attr"))
		modelObjectAttrApp.Register(modelObjectAttrService)
		modelObjectAttrApp.Handle(new(controllers.ModelObjectAttrController))
		
		modelObjectOAMService := service.NewModelObjectOAMService()
		modelObjectOAMApp := mvc.New(modelParty.Party("/object/oam"))
		modelObjectOAMApp.Register(modelObjectOAMService)
		modelObjectOAMApp.Handle(new(controllers.ModelObjectOAMController))
	}
	
	// Biz
	bizParty := b.Party("/biz", crs).AllowMethods(iris.MethodOptions)
	{
		bizParty.Use(middleware.AuthToken)
		bizService := service.NewBizService()
		bizApp := mvc.New(bizParty.Party(""))
		bizApp.Register(bizService)
		bizApp.Handle(new(controllers.BizController))
		
		bizObjectService := service.NewBizObjectService()
		bizObjectApp := mvc.New(bizParty.Party("/object"))
		bizObjectApp.Register(bizObjectService)
		bizObjectApp.Handle(new(controllers.BizObjectController))
		
		bizObjectMappingService := service.NewBizObjectMappingService()
		bizObjectMappingApp := mvc.New(bizParty.Party("/object/mapping"))
		bizObjectMappingApp.Register(bizObjectMappingService)
		bizObjectMappingApp.Handle(new(controllers.BizObjectMappingController))
		
		bizObjectAttrService := service.NewBizObjectAttrService()
		bizObjectAttrApp := mvc.New(bizParty.Party("/object/attr"))
		bizObjectAttrApp.Register(bizObjectAttrService)
		bizObjectAttrApp.Handle(new(controllers.BizObjectAttrController))
		
		bizObjectOAMService := service.NewBizObjectOAMService()
		bizObjectOAMApp := mvc.New(bizParty.Party("/object/oam"))
		bizObjectOAMApp.Register(bizObjectOAMService)
		bizObjectOAMApp.Handle(new(controllers.BizObjectOAMController))
		
		bizRuleService := service.NewBizRuleService()
		bizRuleApp := mvc.New(bizParty.Party("/rule"))
		bizRuleApp.Register(bizRuleService)
		bizRuleApp.Handle(new(controllers.BizRuleController))
		
		bizObjectOAMRuleService := service.NewBizObjectOAMRuleService()
		bizObjectOAMRuleApp := mvc.New(bizParty.Party("/object/oam/rule"))
		bizObjectOAMRuleApp.Register(bizObjectOAMRuleService)
		bizObjectOAMRuleApp.Handle(new(controllers.BizObjectOAMRuleController))
		
		bizObjectOAMParamsService := service.NewBizObjectOAMParamsService()
		bizObjectOAMParamsApp := mvc.New(bizParty.Party("/object/oam/params"))
		bizObjectOAMParamsApp.Register(bizObjectOAMParamsService)
		bizObjectOAMParamsApp.Handle(new(controllers.BizObjectOAMParamsController))
		
		bizObjectOAMMappingService := service.NewBizObjectOAMMappingService()
		bizObjectOAMMappingApp := mvc.New(bizParty.Party("/object/oam/mapping"))
		bizObjectOAMMappingApp.Register(bizObjectOAMMappingService)
		bizObjectOAMMappingApp.Handle(new(controllers.BizObjectOAMMappingController))
	}
	
	// database
	databaseParty := b.Party("/database", crs).AllowMethods(iris.MethodOptions)
	{
		databaseParty.Use(middleware.AuthToken)
		databaseTypeService := service.NewDbTypeService()
		databaseTypeApp := mvc.New(databaseParty.Party("/type"))
		databaseTypeApp.Register(databaseTypeService)
		databaseTypeApp.Handle(new(controllers.DbTypeController))
		
		dataService := service.NewDbTypeService()
		dataApp := mvc.New(databaseParty.Party("/data"))
		dataApp.Register(dataService)
		dataApp.Handle(new(controllers.DbTypeController))
	}
	
	// Api
	apiParty := b.Party("/api", crs).AllowMethods(iris.MethodOptions)
	{
		apiParty.Use(middleware.AuthToken)
		apiService := service.NewApiService()
		apiApp := mvc.New(apiParty.Party(""))
		apiApp.Register(apiService)
		apiApp.Handle(new(controllers.ApiController))
		
		apiLogService := service.NewApiLogService()
		apiLogApp := mvc.New(apiParty.Party("/log"))
		apiLogApp.Register(apiLogService)
		apiLogApp.Handle(new(controllers.ApiLogController))
		
	}
	
	// x
	xParty := b.Party("/x", crs).AllowMethods(iris.MethodOptions)
	{
		xParty.Use(middleware.AuthToken)
		apiGatewayService := service.NewApiGatewayService()
		apiGatewayApp := mvc.New(xParty.Party(""))
		apiGatewayApp.Register(apiGatewayService)
		apiGatewayApp.Handle(new(controllers.ApiGatewayController))
	}
}