package service

import (
	"fmt"
	"github.com/pkg/errors"
	"golang.org/x/net/context"
	"gorm.io/gorm"
	"sghgogs.com/micro/common"
	"sghgogs.com/micro/common/errorcode"
	req "sghgogs.com/micro/shopping-service/domain/model/request"
	pb "sghgogs.com/micro/shopping-service/proto"
	"sghgogs.com/micro/shopping-service/utils"
	"sghgogs.com/micro/shopping-service/utils/authutil"
	"time"
)

func (svc *Service) GetRoleList(query *pb.GetRoleListRequest) ([]*pb.Role, int64, error) {
	list, i, err := svc.Repository.GetRoleList(query)
	roles := make([]*pb.Role, 0)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return roles, 0, nil
		}
		return roles, 0, errorcode.New(svc.Namespace, err.Error(), 500)
	}
	for _, item := range list {
		roles = append(roles, svc.getRoleRes(item))
	}
	return roles, i, nil
}
func (svc *Service) GetAllRoles() ([]*pb.Base, error) {
	roles, err := svc.Repository.GetAllRoles()
	baseList := make([]*pb.Base, 0)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return baseList, nil
		}
		return baseList, errorcode.New(svc.Namespace, err.Error(), 500)
	}
	return svc.getRolesToBase(roles), nil
}
func (svc *Service) GetRole(query *pb.GetRoleRequest) (*pb.Role, error) {
	role, err := svc.Repository.GetRole(query.RoleId)
	if err != nil {
		return &pb.Role{}, errorcode.New(svc.Namespace, err.Error(), 500)
	}
	res := svc.getRoleRes(role)
	res.Permissions = svc.getBasePermissionRes(role.Permissions)
	res.Users = svc.getBaseUserRes(role.Users)
	return res, nil
}

func (svc *Service) CreateRole(ctx context.Context, add *pb.CreateRoleRequest) error {
	_, by, _, _ := utils.ParseMetadata(ctx)
	add.CreatedAt = by
	if err := svc.Repository.CreateRole(add); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	}
	roles, err := svc.Repository.AllRoles()
	if err == nil {
		items := svc.UpdateRulesItems(roles)
		authutil.JWTAuthService.SetRuleItems(items)
	}
	return nil
}

func (svc *Service) UpdateRole(ctx context.Context, query *pb.UpdateRoleRequest) error {
	if exists, err := svc.Repository.IsRoleExists(query.RoleId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	} else {
		if !exists {
			return errorcode.New(svc.Namespace, common.ErrorMessage[common.AccountDoesNotExist], 400)
		}
	}
	_, by, _, _ := utils.ParseMetadata(ctx)
	query.UpdatedBy = by
	if err := svc.Repository.UpdateRole(query); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	}
	return nil
}

func (svc *Service) ToggleRole(ctx context.Context, query *pb.ToggleRoleRequest) error {
	if exists, err := svc.Repository.IsRoleExists(query.RoleId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	} else {
		if !exists {
			return errorcode.New(svc.Namespace, common.ErrorMessage[common.AccountDoesNotExist], 400)
		}
	}
	_, by, _, _ := utils.ParseMetadata(ctx)
	query.UpdatedBy = by
	if err := svc.Repository.ToggleRole(query); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	}
	return nil
}

func (svc *Service) DeleteRole(query *pb.DeleteRoleRequest) error {
	if exists, err := svc.Repository.IsRoleExists(query.RoleId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	} else {
		if !exists {
			return errorcode.New(svc.Namespace, common.ErrorMessage[common.AccountDoesNotExist], 400)
		}
	}
	if err := svc.Repository.DeleteRole(query.RoleId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	}
	return nil
}

func (svc *Service) getBasePermissionRes(permissions []req.Permission) []*pb.Base {
	bases := make([]*pb.Base, 0)
	for _, item := range permissions {
		bases = append(bases, &pb.Base{
			Key:   item.Name,
			Value: fmt.Sprintf("%d", item.ID),
		})
	}
	return bases
}

func (svc *Service) getBaseUserRes(users []req.User) []*pb.Base {
	bases := make([]*pb.Base, 0)
	for _, item := range users {
		bases = append(bases, &pb.Base{
			Key:   item.Username,
			Value: fmt.Sprintf("%d", item.ID),
		})
	}
	return bases
}

func (svc *Service) getRoleRes(role *req.Role) *pb.Role {
	var updatedAt int64
	if role.UpdatedAt != nil {
		if role.CreatedAt.Truncate(time.Second) == role.UpdatedAt.Truncate(time.Second) {
			role.UpdatedAt = nil
		} else {
			updatedAt = utils.ConvertTimeToInt64(*role.UpdatedAt)
		}
	}
	return &pb.Role{
		Id:          role.ID,
		Name:        role.Name,
		Description: role.Description,
		CreatedBy:   role.CreatedBy,
		CreatedAt:   utils.ConvertTimeToInt64(role.CreatedAt),
		UpdatedAt:   updatedAt,
		UpdatedBy:   role.UpdatedBy,
		Status:      role.Status,
		IsReserved:  role.IsReserved,
	}
}