package svc

import (
	"ark-permission/internal/config"
	"ark-permission/internal/domain"
	"ark-permission/internal/domain/repository"
	domainUseCase "ark-permission/internal/domain/usecase"
	"ark-permission/internal/entity"
	"ark-permission/internal/lib/required"
	"ark-permission/internal/model"
	repo "ark-permission/internal/repository"
	"ark-permission/internal/usecase"
	ers "code.30cm.net/wanderland/library-go/errors"
	"code.30cm.net/wanderland/library-go/errors/code"
	"context"
	"github.com/zeromicro/go-zero/core/stores/redis"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

type ServiceContext struct {
	Config config.Config

	Validate       required.Validate
	Redis          redis.Redis
	TokenRedisRepo repository.TokenRepository
	PolicyAgent    domainUseCase.OpaUseCase
	PermissionTree usecase.PermissionTree

	Conn               sqlx.SqlConn
	Permission         model.PermissionModel
	RoleRepo           model.RoleModel
	RolePermissionRepo model.RolePermissionModel
}

func NewServiceContext(c config.Config) *ServiceContext {
	newRedis, err := redis.NewRedis(c.RedisCluster, redis.Cluster())
	if err != nil {
		panic(err)
	}

	ers.Scope = code.CloudEPPermission
	sqlConn := sqlx.NewMysql(c.DB.DsnString)

	pa, err := usecase.NewOpaUseCase(usecase.OpaUseCaseParam{})
	if err != nil {
		panic(err)
	}
	// TODO policy 權限還要再組合過，我的角度會把 UID 當成一種 RoleID 這樣就可以針對每一個人克制權限，，初期也可以使用最簡安的來做統一，再想一下
	err = pa.LoadPolicy(context.Background(), []domainUseCase.Policy{})
	if err != nil {
		panic(err)
	}

	t := usecase.NewPermissionTree()
	pm := model.NewPermissionModel(sqlConn)
	permission, err := pm.FindAllOpenPermission(context.Background())
	if err != nil {
		panic(err)
	}

	for _, item := range permission {
		err := t.AddPermission(item.Id, entity.Permission{
			ID:         item.Id,
			Parent:     item.Parent.Int64,
			Name:       item.Name,
			HTTPPath:   item.HttpPath,
			HTTPMethod: item.HttpMethod,

			Status:     int(item.Status),
			Type:       domain.PermissionType(item.Type),
			CreateTime: item.CreateTime,
			UpdateTime: item.UpdateTime,
		})
		if err != nil {
			continue
		}
	}
	return &ServiceContext{
		Config:   c,
		Validate: required.MustValidator(),
		Redis:    *newRedis,
		TokenRedisRepo: repo.NewTokenRepository(repo.TokenRepositoryParam{
			Store: newRedis,
		}),
		PolicyAgent:        pa,
		PermissionTree:     *t,
		Permission:         pm,
		RoleRepo:           model.NewRoleModel(sqlConn),
		RolePermissionRepo: model.NewRolePermissionModel(sqlConn),
		Conn:               sqlConn,
	}
}