using OrpaonVision.Core.Results;
using OrpaonVision.Model.Security;

namespace OrpaonVision.Core.Security;

/// <summary>
/// 用户仓储接口。
/// </summary>
public interface IUserStore
{
    /// <summary>
    /// 根据用户ID获取用户。
    /// </summary>
    Task<Result<UserModel?>> GetByIdAsync(Guid id);

    /// <summary>
    /// 根据用户名获取用户。
    /// </summary>
    Task<Result<UserModel?>> GetByUsernameAsync(string username);

    /// <summary>
    /// 创建用户。
    /// </summary>
    Task<Result<UserModel>> CreateAsync(UserModel user);

    /// <summary>
    /// 更新用户。
    /// </summary>
    Task<Result<UserModel>> UpdateAsync(UserModel user);

    /// <summary>
    /// 删除用户。
    /// </summary>
    Task<Result> DeleteAsync(Guid id);

    /// <summary>
    /// 检查用户名是否存在。
    /// </summary>
    Task<Result<bool>> UsernameExistsAsync(string username);

    /// <summary>
    /// 获取用户列表（分页）。
    /// </summary>
    Task<Result<(IReadOnlyList<UserModel> users, int totalCount)>> GetPagedListAsync(
        int pageIndex, 
        int pageSize, 
        string? keyword = null, 
        UserStatus? status = null);

    /// <summary>
    /// 更新最后登录信息。
    /// </summary>
    Task<Result> UpdateLastLoginAsync(Guid userId, string ipAddress);
}

/// <summary>
/// 角色仓储接口。
/// </summary>
public interface IRoleStore
{
    /// <summary>
    /// 根据角色ID获取角色。
    /// </summary>
    Task<Result<RoleModel?>> GetByIdAsync(Guid id);

    /// <summary>
    /// 根据角色名称获取角色。
    /// </summary>
    Task<Result<RoleModel?>> GetByNameAsync(string name);

    /// <summary>
    /// 创建角色。
    /// </summary>
    Task<Result<RoleModel>> CreateAsync(RoleModel role);

    /// <summary>
    /// 更新角色。
    /// </summary>
    Task<Result<RoleModel>> UpdateAsync(RoleModel role);

    /// <summary>
    /// 删除角色。
    /// </summary>
    Task<Result> DeleteAsync(Guid id);

    /// <summary>
    /// 检查角色名称是否存在。
    /// </summary>
    Task<Result<bool>> NameExistsAsync(string name);

    /// <summary>
    /// 获取角色列表（分页）。
    /// </summary>
    Task<Result<(IReadOnlyList<RoleModel> roles, int totalCount)>> GetPagedListAsync(
        int pageIndex, 
        int pageSize, 
        string? keyword = null, 
        RoleStatus? status = null);

    /// <summary>
    /// 获取所有启用的角色。
    /// </summary>
    Task<Result<IReadOnlyList<RoleModel>>> GetAllEnabledAsync();
}

/// <summary>
/// 权限仓储接口。
/// </summary>
public interface IPermissionStore
{
    /// <summary>
    /// 根据权限ID获取权限。
    /// </summary>
    Task<Result<PermissionModel?>> GetByIdAsync(Guid id);

    /// <summary>
    /// 根据权限编码获取权限。
    /// </summary>
    Task<Result<PermissionModel?>> GetByCodeAsync(string code);

    /// <summary>
    /// 创建权限。
    /// </summary>
    Task<Result<PermissionModel>> CreateAsync(PermissionModel permission);

    /// <summary>
    /// 更新权限。
    /// </summary>
    Task<Result<PermissionModel>> UpdateAsync(PermissionModel permission);

    /// <summary>
    /// 删除权限。
    /// </summary>
    Task<Result> DeleteAsync(Guid id);

    /// <summary>
    /// 检查权限编码是否存在。
    /// </summary>
    Task<Result<bool>> CodeExistsAsync(string code);

    /// <summary>
    /// 获取权限列表（分页）。
    /// </summary>
    Task<Result<(IReadOnlyList<PermissionModel> permissions, int totalCount)>> GetPagedListAsync(
        int pageIndex, 
        int pageSize, 
        string? keyword = null, 
        PermissionType? type = null, 
        PermissionStatus? status = null);

    /// <summary>
    /// 根据模块获取权限列表。
    /// </summary>
    Task<Result<IReadOnlyList<PermissionModel>>> GetByModuleAsync(string module);

    /// <summary>
    /// 获取所有启用的权限。
    /// </summary>
    Task<Result<IReadOnlyList<PermissionModel>>> GetAllEnabledAsync();
}

/// <summary>
/// 用户角色仓储接口。
/// </summary>
public interface IUserRoleStore
{
    /// <summary>
    /// 分配角色给用户。
    /// </summary>
    Task<Result<UserRoleModel>> AssignAsync(Guid userId, Guid roleId, string grantedBy);

    /// <summary>
    /// 取消用户角色分配。
    /// </summary>
    Task<Result> UnassignAsync(Guid userId, Guid roleId);

    /// <summary>
    /// 获取用户的角色列表。
    /// </summary>
    Task<Result<IReadOnlyList<RoleModel>>> GetUserRolesAsync(Guid userId);

    /// <summary>
    /// 获取角色的用户列表。
    /// </summary>
    Task<Result<IReadOnlyList<UserModel>>> GetRoleUsersAsync(Guid roleId);

    /// <summary>
    /// 检查用户是否拥有指定角色。
    /// </summary>
    Task<Result<bool>> UserHasRoleAsync(Guid userId, Guid roleId);

    /// <summary>
    /// 检查用户是否拥有指定角色名称。
    /// </summary>
    Task<Result<bool>> UserHasRoleAsync(Guid userId, string roleName);

    /// <summary>
    /// 获取用户角色关联记录。
    /// </summary>
    Task<Result<UserRoleModel?>> GetAssignmentAsync(Guid userId, Guid roleId);

    /// <summary>
    /// 更新用户角色关联状态。
    /// </summary>
    Task<Result<UserRoleModel>> UpdateAssignmentAsync(UserRoleModel userRole);

    /// <summary>
    /// 获取用户角色关联列表（分页）。
    /// </summary>
    Task<Result<(IReadOnlyList<UserRoleModel> assignments, int totalCount)>> GetPagedListAsync(
        int pageIndex, 
        int pageSize, 
        Guid? userId = null, 
        Guid? roleId = null);
}

/// <summary>
/// 角色权限仓储接口。
/// </summary>
public interface IRolePermissionStore
{
    /// <summary>
    /// 分配权限给角色。
    /// </summary>
    Task<Result<RolePermissionModel>> AssignAsync(Guid roleId, Guid permissionId, string grantedBy);

    /// <summary>
    /// 取消角色权限分配。
    /// </summary>
    Task<Result> UnassignAsync(Guid roleId, Guid permissionId);

    /// <summary>
    /// 获取角色的权限列表。
    /// </summary>
    Task<Result<IReadOnlyList<PermissionModel>>> GetRolePermissionsAsync(Guid roleId);

    /// <summary>
    /// 获取权限的角色列表。
    /// </summary>
    Task<Result<IReadOnlyList<RoleModel>>> GetPermissionRolesAsync(Guid permissionId);

    /// <summary>
    /// 检查角色是否拥有指定权限。
    /// </summary>
    Task<Result<bool>> RoleHasPermissionAsync(Guid roleId, Guid permissionId);

    /// <summary>
    /// 检查角色是否拥有指定权限编码。
    /// </summary>
    Task<Result<bool>> RoleHasPermissionAsync(Guid roleId, string permissionCode);

    /// <summary>
    /// 获取角色权限关联记录。
    /// </summary>
    Task<Result<RolePermissionModel?>> GetAssignmentAsync(Guid roleId, Guid permissionId);

    /// <summary>
    /// 更新角色权限关联状态。
    /// </summary>
    Task<Result<RolePermissionModel>> UpdateAssignmentAsync(RolePermissionModel rolePermission);

    /// <summary>
    /// 获取角色权限关联列表（分页）。
    /// </summary>
    Task<Result<(IReadOnlyList<RolePermissionModel> assignments, int totalCount)>> GetPagedListAsync(
        int pageIndex, 
        int pageSize, 
        Guid? roleId = null, 
        Guid? permissionId = null);
}

/// <summary>
/// 操作日志仓储接口。
/// </summary>
public interface IOperationLogStore
{
    /// <summary>
    /// 记录操作日志。
    /// </summary>
    Result<OperationLogModel> LogAsync(OperationLogModel log);

    /// <summary>
    /// 获取操作日志列表（分页）。
    /// </summary>
    Result<(IReadOnlyList<OperationLogModel> logs, int totalCount)> GetPagedListAsync(
        int pageIndex, 
        int pageSize, 
        Guid? userId = null, 
        OperationType? operationType = null, 
        string? module = null, 
        DateTime? startTime = null, 
        DateTime? endTime = null);

    /// <summary>
    /// 获取用户最近的操作日志。
    /// </summary>
    Result<IReadOnlyList<OperationLogModel>> GetUserRecentLogsAsync(Guid userId, int count = 10);

    /// <summary>
    /// 清理过期日志。
    /// </summary>
    Result<int> CleanupExpiredLogsAsync(DateTime expireBefore);
}