superport/lib/screens/user/controllers/user_form_controller.dart

import 'dart:async';
import 'package:flutter/material.dart';
import 'package:get_it/get_it.dart';
import 'package:superport/models/user_model.dart';
import 'package:superport/domain/usecases/user/create_user_usecase.dart';
import 'package:superport/domain/repositories/user_repository.dart';
import 'package:superport/domain/repositories/company_repository.dart';
import 'package:superport/data/datasources/remote/user_remote_datasource.dart';
import 'package:superport/core/errors/failures.dart';

/// 사용자 폼 컨트롤러 (서버 API v0.2.1 대응)
/// Clean Architecture Presentation Layer - 필수 필드 검증 강화 및 전화번호 UI 개선
class UserFormController extends ChangeNotifier {
  final CreateUserUseCase _createUserUseCase = GetIt.instance<CreateUserUseCase>();
  final UserRepository _userRepository = GetIt.instance<UserRepository>();
  final CompanyRepository _companyRepository = GetIt.instance<CompanyRepository>();
  final UserRemoteDataSource _userRemoteDataSource = GetIt.instance<UserRemoteDataSource>();
  final GlobalKey<FormState> formKey = GlobalKey<FormState>();

  // 상태 변수
  bool _isLoading = false;
  String? _error;
  
  // 폼 필드 (백엔드 스키마 완전 일치)
  bool isEditMode = false;
  int? userId;
  String name = '';                    // 필수
  String email = '';                  // 선택
  String? phone;                      // 선택, "010-1234-5678" 형태
  int? companiesId;                   // 필수, 회사 ID (백엔드 요구사항)
  
  // 전화번호 UI 지원 (드롭다운 + 텍스트 필드)
  String phonePrefix = '010';         // 010, 02, 031 등
  String phoneNumber = '';            // 7-8자리 숫자
  final List<String> phonePrefixes = [
    '010', '011', '016', '017', '018', '019',  // 휴대폰
    '02',                                      // 서울
    '031', '032', '033',                       // 경기도
    '041', '042', '043', '044',                // 충청도
    '051', '052', '053', '054', '055',         // 경상도
    '061', '062', '063', '064',                // 전라도
    '070',                                     // 인터넷전화
  ];
  
  // 이메일 중복 확인 (저장 시점 검사용)
  bool _isCheckingEmailDuplicate = false;
  String? _emailDuplicateMessage;
  
  // 회사 목록 (드롭다운용)
  Map<int, String> _companies = {};
  bool _isLoadingCompanies = false;
  
  // Getters
  bool get isLoading => _isLoading;
  String? get error => _error;
  bool get isCheckingEmailDuplicate => _isCheckingEmailDuplicate;
  String? get emailDuplicateMessage => _emailDuplicateMessage;
  Map<int, String> get companies => _companies;
  bool get isLoadingCompanies => _isLoadingCompanies;
  
  /// 현재 전화번호 (드롭다운 + 텍스트 필드 → 통합 형태)
  String get combinedPhoneNumber {
    if (phoneNumber.isEmpty) return '';
    return PhoneNumberUtil.combineFromUI(phonePrefix, phoneNumber);
  }
  
  /// 필수 필드 완성 여부 확인
  bool get isFormValid {
    return name.isNotEmpty &&
           companiesId != null;
  }

  UserFormController({this.userId}) {
    isEditMode = userId != null;
    // 모든 초기화는 initialize() 메서드에서만 수행
  }
  
  /// 비동기 초기화 메서드
  Future<void> initialize() async {
    // 항상 회사 목록부터 로드 (사용자 정보에서 회사 검증을 위해)
    await _loadCompanies();
    
    // 수정 모드인 경우에만 사용자 정보 로드
    if (isEditMode && userId != null) {
      await _loadUser();
    }
  }

  /// 전화번호 접두사 변경
  void updatePhonePrefix(String prefix) {
    phonePrefix = prefix;
    phone = combinedPhoneNumber;
    notifyListeners();
  }

  /// 전화번호 번호 부분 변경
  void updatePhoneNumber(String number) {
    phoneNumber = number;
    phone = combinedPhoneNumber;
    notifyListeners();
  }

  /// 사용자 정보 로드 (수정 모드, 서버 API v0.2.1 대응)
  Future<void> _loadUser() async {
    if (userId == null) return;
    
    _isLoading = true;
    _error = null;
    notifyListeners();
    
    try {
      // UserDto에서 직접 companiesId를 가져오기 위해 DataSource 사용
      final userDto = await _userRemoteDataSource.getUser(userId!);
      
      // UserDto에서 정보 추출 (null safety 보장)
      name = userDto.name ?? '';
      email = userDto.email ?? '';
      companiesId = userDto.companiesId;
      
      // 전화번호 UI 분리 (서버: "010-1234-5678" → UI: 접두사 + 번호)
      if (userDto.phone != null && userDto.phone!.isNotEmpty) {
        final phoneData = PhoneNumberUtil.splitForUI(userDto.phone);
        phonePrefix = phoneData['prefix'] ?? '010';
        phoneNumber = phoneData['number'] ?? '';
        phone = userDto.phone;
      }
      
      // 회사가 목록에 없는 경우 처리
      if (companiesId != null && !_companies.containsKey(companiesId)) {
        debugPrint('Warning: 사용자의 회사 ID ($companiesId)가 회사 목록에 없습니다.');
        // 임시로 "알 수 없는 회사" 항목 추가
        _companies[companiesId!] = '알 수 없는 회사 (ID: $companiesId)';
      }
      
    } catch (e) {
      _error = '사용자 정보를 불러올 수 없습니다: ${e.toString()}';
    } finally {
      _isLoading = false;
      notifyListeners();
    }
  }
  
  /// 회사 목록 로드
  Future<void> _loadCompanies() async {
    _isLoadingCompanies = true;
    notifyListeners();
    
    try {
      final result = await _companyRepository.getCompanies();
      
      result.fold(
        (failure) {
          debugPrint('회사 목록 로드 실패: ${failure.message}');
        },
        (paginatedResponse) {
          _companies = {};
          for (final company in paginatedResponse.items) {
            if (company.id != null) {
              _companies[company.id!] = company.name;
            }
          }
        },
      );
    } catch (e) {
      debugPrint('회사 목록 로드 오류: $e');
    } finally {
      _isLoadingCompanies = false;
      notifyListeners();
    }
  }
  

  /// 이메일 중복 검사 (저장 시점에만 실행)
  Future<bool> checkDuplicateEmail(String email) async {
    if (email.isEmpty) return true;
    
    _isCheckingEmailDuplicate = true;
    _emailDuplicateMessage = null;
    notifyListeners();
    
    try {
      // GET /users 엔드포인트를 사용하여 이메일 중복 확인
      final result = await _userRepository.getUsers();
      
      return result.fold(
        (failure) {
          _emailDuplicateMessage = '중복 검사 중 오류가 발생했습니다';
          notifyListeners();
          return false;
        },
        (paginatedResponse) {
          final users = paginatedResponse.items;
          
          // 수정 모드일 경우 자기 자신 제외
          final isDuplicate = users.any((user) => 
            user.email?.toLowerCase() == email.toLowerCase() && 
            (!isEditMode || user.id != userId)
          );
          
          if (isDuplicate) {
            _emailDuplicateMessage = '이미 사용 중인 이메일입니다';
          } else {
            _emailDuplicateMessage = null;
          }
          
          notifyListeners();
          return !isDuplicate;
        },
      );
    } catch (e) {
      _emailDuplicateMessage = '네트워크 오류가 발생했습니다';
      notifyListeners();
      return false;
    } finally {
      _isCheckingEmailDuplicate = false;
      notifyListeners();
    }
  }
  
  /// 중복 검사 메시지 초기화
  void clearDuplicateMessage() {
    _emailDuplicateMessage = null;
    notifyListeners();
  }

  /// 사용자 저장 (서버 API v0.2.1 대응)
  Future<void> saveUser(Function(String? error) onResult) async {
    // 폼 유효성 검사
    if (formKey.currentState?.validate() != true) {
      onResult('폼 유효성 검사를 통과하지 못했습니다.');
      return;
    }
    formKey.currentState?.save();
    
    // 필수 필드 검증
    if (name.trim().isEmpty) {
      onResult('이름을 입력해주세요.');
      return;
    }
    if (companiesId == null) {
      onResult('회사를 선택해주세요.');
      return;
    }
    
    _isLoading = true;
    _error = null;
    notifyListeners();
    
    try {
      // 전화번호 통합 (드롭다운 + 텍스트 → 서버 형태)
      final phoneNumber = combinedPhoneNumber;
      
      if (isEditMode && userId != null) {
        // 사용자 수정
        final userToUpdate = User(
          id: userId,
          name: name,
          email: email.isNotEmpty ? email : null,
          phone: phoneNumber.isEmpty ? null : phoneNumber,
        );
        
        final result = await _userRepository.updateUser(
          userId!,
          userToUpdate,
        );
        
        result.fold(
          (failure) => onResult(_mapFailureToString(failure)),
          (_) => onResult(null),
        );
      } else {
        // 사용자 생성 (백엔드 API v1 준수)
        final params = CreateUserParams(
          name: name,
          email: email.isEmpty ? null : email,
          phone: phoneNumber.isEmpty ? null : phoneNumber,
          companiesId: companiesId!, // 선택된 회사 ID 사용
        );
        
        final result = await _createUserUseCase(params);
        
        result.fold(
          (failure) => onResult(_mapFailureToString(failure)),
          (_) => onResult(null),
        );
      }
    } catch (e) {
      _error = '사용자 저장 중 오류가 발생했습니다: ${e.toString()}';
      onResult(_error);
    } finally {
      _isLoading = false;
      notifyListeners();
    }
  }

  
  /// 입력값 유효성 검증 (실시간)
  Map<String, String?> validateFields() {
    final errors = <String, String?>{};
    
    if (name.trim().isEmpty) {
      errors['name'] = '이름을 입력해주세요.';
    }
    
    if (email.isNotEmpty && !RegExp(r'^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$').hasMatch(email)) {
      errors['email'] = '올바른 이메일 형식이 아닙니다.';
    }
    
    if (phoneNumber.isNotEmpty && !RegExp(r'^\d{7,8}$').hasMatch(phoneNumber)) {
      errors['phone'] = '전화번호는 7-8자리 숫자로 입력해주세요.';
    }
    
    return errors;
  }

  /// Failure를 사용자 친화적 메시지로 변환
  String _mapFailureToString(Failure failure) {
    if (failure is ValidationFailure) {
      return failure.message;
    } else if (failure is DuplicateFailure) {
      return '이미 사용 중인 사용자명 또는 이메일입니다.';
    } else if (failure is NotFoundFailure) {
      return '사용자를 찾을 수 없습니다.';
    } else if (failure is AuthenticationFailure) {
      return '인증이 필요합니다.';
    } else if (failure is AuthorizationFailure) {
      return '권한이 없습니다.';
    } else {
      return failure.message;
    }
  }

  /// 컨트롤러 해제
  @override
  void dispose() {
    super.dispose();
  }
}