package rbac

import (
	"fmt"
	"strings"
	"uauth/internal/interfaces"
	"uauth/internal/store/cache"
	"uauth/internal/store/db"
	"uauth/internal/tool"
	"uauth/model"
)

type Urbac struct {
	cache interfaces.Cacher
	store interfaces.Store
}

type Option func(u *Urbac)

func New(opts ...Option) (*Urbac, error) {
	var (
		err           error
		u             = &Urbac{}
		rootPrivilege *model.Privilege
		rootRole      *model.Role
		rootScope     *model.Scope
		rootUser      *model.User
	)

	for _, opt := range opts {
		opt(u)
	}

	if u.store == nil {
		u.store = db.Default
	}

	if u.cache == nil {
		u.cache = cache.Client
	}

	if err = u.store.Session(tool.Timeout()).AutoMigrate(&model.Scope{}, &model.Privilege{}, &model.Role{}); err != nil {
		return nil, fmt.Errorf("urbac migrate err: %w", err)
	}

	if rootPrivilege, err = u.newPrivilege(tool.Timeout(), "*:*:*:*", "admin", "", "*"); err != nil {
		if !strings.Contains(strings.ToLower(err.Error()), "unique") {
			return nil, err
		}
	}

	if rootRole, err = u.newRole(tool.Timeout(), "admin", "管理员", "", rootPrivilege); err != nil {
		if !strings.Contains(strings.ToLower(err.Error()), "unique") {
			return nil, err
		}
	}

	if rootScope, err = u.newScope(tool.Timeout(), "*", "全部", ""); err != nil {
		if !strings.Contains(strings.ToLower(err.Error()), "unique") {
			return nil, err
		}
	}

	rootUser = &model.User{
		Username:  "admin",
		Password:  tool.NewPassword("123456"),
		Status:    model.StatusActive,
		Nickname:  "管理员",
		RoleNames: []string{rootRole.Code},
	}

	_, err = u.newUser(rootUser)

	return u, err
}