package repository

import (
	"fmt"
	"github.com/pkg/errors"
	"sghgogs.com/micro/shopping-service/domain/model/base"
	req "sghgogs.com/micro/shopping-service/domain/model/request"
	pb "sghgogs.com/micro/shopping-service/proto"
)

func (u *Repository) GetPermissionList(query *pb.GetPermissionListRequest) ([]*req.Permission, int64, error) {
	var totalCount int64
	tx := u.db.Model(&req.Permission{}).Order("id desc").
		Preload("Roles", "status = ?", pb.StatusEnum_ENABLED)
	if query.Keyword != "" {
		tx.Where("name = ?", query.Keyword)
	}
	if base.IsStatusEnum(query.Status) {
		tx.Where("status = ?", query.Status)
	}
	tx.Count(&totalCount)
	permissions := make([]*req.Permission, 0)
	return permissions, totalCount, tx.Limit(int(query.PageSize)).Offset(int((query.Page - 1) * query.PageSize)).Find(&permissions).Error
}

func (u *Repository) GetPermission(permissionID int64) (*req.Permission, error) {
	var permission req.Permission
	return &permission, u.db.Where("id = ? ", permissionID).
		Where("status = ?", pb.StatusEnum_ENABLED).
		Preload("Roles", "status = ?", pb.StatusEnum_ENABLED).
		First(&permission).Error
}

func (u *Repository) CreatePermission(permission *req.Permission, roleIds []int64) error {
	// 开始事务
	tx := u.db.Begin()
	// 错误处理
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	if err := tx.Create(&permission).Error; err != nil {
		tx.Rollback()
		return err
	}
	if len(roleIds) > 0 {
		if _, err := u.getPermissionValidIDs(roleIds); err != nil {
			tx.Rollback()
			return err
		}
		roles := make([]req.Role, 0)
		for _, ID := range roleIds {
			roles = append(roles, req.Role{ID: ID})
		}
		if err := tx.Model(&permission).Association("Roles").Append(&roles); err != nil {
			tx.Rollback()
			return err
		}
	}
	return tx.Commit().Error
}

func (u *Repository) UpdatePermission(permissionID int64, newPermission map[string]interface{}, oldRoles []int64) error {
	// 开始事务
	tx := u.db.Begin()
	// 错误处理
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	var oldPermission req.Permission
	if err := tx.First(&oldPermission, permissionID).Error; err != nil {
		tx.Rollback()
		return err
	}
	if err := tx.Model(&oldPermission).Association("Roles").Clear(); err != nil {
		tx.Rollback()
		return err
	}
	if len(oldRoles) > 0 {
		if _, err := u.getRoleValidIDs(oldRoles); err != nil {
			tx.Rollback()
			return err
		}
		newRoles := make([]req.Role, 0)
		for _, ID := range oldRoles {
			newRoles = append(newRoles, req.Role{ID: ID})
		}
		if err := tx.Model(&oldPermission).Association("Roles").Append(&newRoles); err != nil {
			tx.Rollback()
			return err
		}
	}
	if err := tx.Model(&oldPermission).Updates(newPermission).Error; err != nil {
		tx.Rollback()
		return err
	}
	return tx.Commit().Error
}

func (u *Repository) DeletePermission(permissionID int64) error {
	// 开始事务
	tx := u.db.Begin()
	// 错误处理
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	var permission req.Permission
	if err := tx.First(&permission, permissionID).Error; err != nil {
		tx.Rollback()
		return err
	}
	if err := tx.Model(&permission).Association("Roles").Clear(); err != nil {
		tx.Rollback()
		return err
	}
	if err := tx.Model(&req.Permission{}).Delete(&req.Permission{
		ID: permissionID,
	}).Error; err != nil {
		tx.Rollback()
		return err
	}
	return tx.Commit().Error
}

func (u *Repository) TogglePermission(permissionID int64, permission map[string]interface{}) error {
	// 开始事务
	tx := u.db.Begin()
	// 错误处理
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	if err := tx.Model(&req.Permission{}).Where("id = ?", permissionID).Updates(permission).Error; err != nil {
		tx.Rollback()
		return err
	}
	return tx.Commit().Error
}

func (u *Repository) CreateMultiplePermissions(permissions []*req.Permission, roleIds []int64) error {
	// 开始事务
	tx := u.db.Begin()
	// 错误处理
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	if err := tx.Create(&permissions).Error; err != nil {
		tx.Rollback()
		return err
	}
	if len(roleIds) > 0 {
		if _, err := u.getRoleValidIDs(roleIds); err != nil {
			tx.Rollback()
			return err
		}
		roleInstance := &req.Role{}
		for _, ID := range roleIds {
			roleInstance.ID = ID
			if err := tx.Model(roleInstance).Association("Permissions").Append(permissions); err != nil {
				tx.Rollback()
				return err
			}
		}
	}
	return tx.Commit().Error
}

func (u *Repository) getPermissionValidIDs(ids []int64) ([]int64, error) {
	var validIDs []int64
	result := u.db.Model(&req.Permission{}).Where("id IN ?", ids).Pluck("id", &validIDs)
	if result.Error != nil {
		return nil, result.Error
	}
	// 检查是否有未找到的 ID
	if result.RowsAffected != int64(len(ids)) {
		// 找到的 ID 数量和传入的数量不一致，说明有不存在的 ID
		missingIDs := findMissingIDs(ids, validIDs)
		errMsg := fmt.Sprintf("Some IDs do not exist: %v", missingIDs)
		return nil, errors.New(errMsg)
	}
	return validIDs, nil
}