package com.knowledge.base.application.service;

import com.knowledge.base.domain.user.repository.po.*;
import com.knowledge.base.domain.user.service.iface.UserDomainService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
@RequiredArgsConstructor
public class UserAppServiceImpl implements UserAppService {

    private final UserDomainService userDomainService;

    @Override
    public boolean registerUser(String username, String password, List<Long> roleIds) {
        boolean ok = userDomainService.registerUser(username, password);
        if (!ok) return false;
        Optional<User> userOpt = userDomainService.findByUsername(username);
        if (userOpt.isEmpty()) return false;
        Long userId = userOpt.get().getId();
        for (Long roleId : roleIds) {
            userDomainService.addUserRole(userId, roleId);
        }
        return true;
    }

    @Override
    public boolean verifyPassword(String username, String plainText) {
        return userDomainService.verifyPassword(username, plainText);
    }

    @Override
    public Optional<User> findByUsername(String username) {
        return userDomainService.findByUsername(username);
    }

    @Override
    public Optional<User> findById(Long id) {
        return userDomainService.findById(id);
    }

    @Override
    public List<User> findAll() {
        return userDomainService.findAllUsers();
    }

    @Override
    public UserToken createToken(Long userId, long expireMs) {
        return userDomainService.createToken(userId, expireMs);
    }

    @Override
    public void removeToken(String token) {
        userDomainService.removeToken(token);
    }

    @Override
    public boolean isValidToken(String token) {
        return userDomainService.isValidToken(token);
    }

    @Override
    public Optional<UserToken> findToken(String token) {
        return userDomainService.findToken(token);
    }

    @Override
    public List<UserRole> listUserRoles(Long userId) {
        return userDomainService.findRolesByUserId(userId);
    }

    @Override
    public boolean addUserRole(Long userId, Long roleId) {
        return userDomainService.addUserRole(userId, roleId);
    }

    @Override
    public boolean removeUserRole(Long userId, Long roleId) {
        return userDomainService.removeUserRole(userId, roleId);
    }

    @Override
    public List<UserFile> listUserFiles(Long userId) {
        return userDomainService.findUserFiles(userId);
    }

    @Override
    public boolean addUserFileAuth(Long userId, Long fileId) {
        return userDomainService.addUserFileAuth(userId, fileId);
    }

    @Override
    public boolean removeUserFileAuth(Long userId, Long fileId) {
        return userDomainService.removeUserFileAuth(userId, fileId);
    }

    @Override
    public List<Role> listRoles() {
        return userDomainService.findAllRoles();
    }

    @Override
    public Optional<Role> getRoleById(Long roleId) {
        return userDomainService.findRoleById(roleId);
    }

    @Override
    public boolean addRole(Role role) {
        return userDomainService.addRole(role);
    }

    @Override
    public boolean updateRole(Role role) {
        return userDomainService.updateRole(role);
    }

    @Override
    public boolean deleteRole(Long id) {
        return userDomainService.deleteRole(id);
    }

    @Override
    public List<RoleFileRule> listRoleFileRules(Long roleId) {
        return userDomainService.findRoleFileRules(roleId);
    }

    @Override
    public boolean addRoleFileRule(RoleFileRule rule) {
        return userDomainService.addRoleFileRule(rule);
    }

    @Override
    public boolean removeRoleFileRule(Long id) {
        return userDomainService.removeRoleFileRule(id);
    }
}