superport/lib/services/user_service.dart

import 'package:injectable/injectable.dart';
import 'package:superport/data/datasources/remote/user_remote_datasource.dart';
import 'package:superport/data/models/common/paginated_response.dart';
import 'package:superport/data/models/user/user_dto.dart';
import 'package:superport/models/user_model.dart';

@lazySingleton
class UserService {
  final UserRemoteDataSource _userRemoteDataSource;

  UserService(this._userRemoteDataSource);

  /// 사용자 목록 조회 (레거시 메서드 - 사용 중단됨)
  Future<PaginatedResponse<User>> getUsers({
    int page = 1,
    int perPage = 20,
    bool? isActive,
    int? companyId,
    String? role,
    bool includeInactive = false,
  }) async {
    try {
      final response = await _userRemoteDataSource.getUsers(
        page: page,
        perPage: perPage,
        isActive: isActive,
        role: role,
      );

      return PaginatedResponse<User>(
        items: response.users.map((dto) => _userDtoToModel(dto)).toList(),
        page: response.page,
        size: response.perPage,
        totalElements: response.total,
        totalPages: response.totalPages,
        first: response.page == 1,
        last: response.page >= response.totalPages,
      );
    } catch (e) {
      throw Exception('사용자 목록 조회 실패: ${e.toString()}');
    }
  }

  /// 특정 사용자 조회
  Future<User> getUser(int id) async {
    try {
      final dto = await _userRemoteDataSource.getUser(id);
      return _userDtoToModel(dto);
    } catch (e) {
      throw Exception('사용자 조회 실패: ${e.toString()}');
    }
  }

  /// 사용자 생성
  Future<User> createUser({
    required String username,
    required String email,
    required String password,
    required String name,
    required String role,
    required int companyId,
    int? branchId,
    String? phone,
    String? position,
  }) async {
    try {
      final request = CreateUserRequest(
        username: username,
        email: email,
        password: password,
        name: name,
        role: _mapRoleToApi(role),
        phone: phone,
      );

      final dto = await _userRemoteDataSource.createUser(request);
      return _userDtoToModel(dto);
    } catch (e) {
      throw Exception('사용자 생성 실패: ${e.toString()}');
    }
  }

  /// 사용자 정보 수정
  Future<User> updateUser(
    int id, {
    String? name,
    String? email,
    String? password,
    String? phone,
    int? companyId,
    int? branchId,
    String? role,
    String? position,
  }) async {
    try {
      final request = UpdateUserRequest(
        name: name,
        email: email,
        password: password,
        phone: phone,
        role: role != null ? _mapRoleToApi(role) : null,
      );

      final dto = await _userRemoteDataSource.updateUser(id, request);
      return _userDtoToModel(dto);
    } catch (e) {
      throw Exception('사용자 수정 실패: ${e.toString()}');
    }
  }

  /// 사용자 삭제
  Future<void> deleteUser(int id) async {
    try {
      await _userRemoteDataSource.deleteUser(id);
    } catch (e) {
      throw Exception('사용자 삭제 실패: ${e.toString()}');
    }
  }

  /// 사용자 상태 변경 - 레거시 메서드 비활성화
  Future<User> changeUserStatus(int id, bool isActive) async {
    throw UnimplementedError('레거시 메서드 - UserRepository 사용');
  }

  /// 비밀번호 변경 - 레거시 메서드 비활성화
  Future<void> changePassword(
    int id,
    String currentPassword,
    String newPassword,
  ) async {
    throw UnimplementedError('레거시 메서드 - UserRepository 사용');
  }

  /// 관리자가 사용자 비밀번호 재설정 - 레거시 메서드 비활성화
  Future<bool> resetPassword({
    required int userId,
    required String newPassword,
  }) async {
    throw UnimplementedError('레거시 메서드 - UserRepository 사용');
  }

  /// 사용자 상태 토글 (활성화/비활성화)
  Future<User> toggleUserStatus(int userId) async {
    try {
      // 현재 사용자 정보 조회
      final currentUser = await getUser(userId);
      
      // 상태 반전
      final newStatus = !currentUser.isActive;
      
      // 상태 변경 실행
      return await changeUserStatus(userId, newStatus);
    } catch (e) {
      throw Exception('사용자 상태 토글 실패: ${e.toString()}');
    }
  }

  /// 사용자명 중복 확인 - 레거시 메서드 비활성화
  Future<bool> checkDuplicateUsername(String username) async {
    throw UnimplementedError('레거시 메서드 - UserRepository 사용');
  }

  /// 사용자 검색 - 레거시 메서드 비활성화
  Future<List<User>> searchUsers({
    required String query,
    int? companyId,
    String? status,
    String? permissionLevel,
    int page = 1,
    int perPage = 20,
  }) async {
    throw UnimplementedError('레거시 메서드 - UserRepository 사용');
  }

  /// DTO를 Model로 변환 (새로운 User 모델 구조 대응)
  User _userDtoToModel(UserDto dto) {
    return User(
      id: dto.id,
      username: dto.username,
      email: dto.email,
      name: dto.name,
      phone: dto.phone,
      role: UserRole.fromString(dto.role),
      isActive: dto.isActive,
      createdAt: dto.createdAt,
      updatedAt: dto.updatedAt,
    );
  }

  /// 권한을 API 형식으로 변환
  String _mapRoleToApi(String role) {
    switch (role) {
      case 'S':
        return 'admin';
      case 'M':
        return 'staff';
      default:
        return 'staff';
    }
  }

  /// API 권한을 앱 형식으로 변환
  String _mapRoleFromApi(String? role) {
    if (role == null) return 'M'; // null인 경우 기본값
    
    switch (role) {
      case 'admin':
        return 'S';
      case 'manager':
        return 'M';
      case 'staff':
        return 'M';
      default:
        return 'M';
    }
  }

  /// 전화번호 목록에서 첫 번째 전화번호 추출
  String? getPhoneForApi(List<Map<String, String>> phoneNumbers) {
    if (phoneNumbers.isEmpty) return null;
    return phoneNumbers.first['number'];
  }
}