superport/lib/services/equipment_service.dart

import 'package:get_it/get_it.dart';
import 'package:superport/core/errors/exceptions.dart';
import 'package:superport/core/errors/failures.dart';
import 'package:superport/core/utils/equipment_status_converter.dart';
import 'package:superport/data/datasources/remote/equipment_remote_datasource.dart';
import 'package:superport/data/models/common/paginated_response.dart';
import 'package:superport/data/models/equipment/equipment_history_dto.dart';
import 'package:superport/data/models/equipment/equipment_in_request.dart';
import 'package:superport/data/models/equipment/equipment_io_response.dart';
import 'package:superport/data/models/equipment/equipment_list_dto.dart';
import 'package:superport/data/models/equipment/equipment_out_request.dart';
import 'package:superport/data/models/equipment/equipment_request.dart';
import 'package:superport/data/models/equipment/equipment_response.dart';
import 'package:superport/models/equipment_unified_model.dart';

class EquipmentService {
  final EquipmentRemoteDataSource _remoteDataSource = GetIt.instance<EquipmentRemoteDataSource>();

  // 장비 목록 조회 (DTO 형태로 반환하여 status 정보 유지)
  Future<PaginatedResponse<EquipmentListDto>> getEquipmentsWithStatus({
    int page = 1,
    int perPage = 20,
    String? status,
    int? companyId,
    int? warehouseLocationId,
    String? search,
    bool includeInactive = false,
  }) async {
    try {
      final response = await _remoteDataSource.getEquipments(
        page: page,
        perPage: perPage,
        status: status,
        companyId: companyId,
        warehouseLocationId: warehouseLocationId,
        search: search,
        isActive: !includeInactive,
      );

      return PaginatedResponse<EquipmentListDto>(
        items: response.items,
        page: response.page,
        size: response.perPage,
        totalElements: response.total,
        totalPages: response.totalPages,
        first: response.page == 1,
        last: response.page >= response.totalPages,
      );
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to fetch equipment list: $e');
    }
  }

  // 장비 목록 조회
  Future<PaginatedResponse<Equipment>> getEquipments({
    int page = 1,
    int perPage = 20,
    String? status,
    int? companyId,
    int? warehouseLocationId,
    String? search,
    bool includeInactive = false,
  }) async {
    try {
      final response = await _remoteDataSource.getEquipments(
        page: page,
        perPage: perPage,
        status: status,
        companyId: companyId,
        warehouseLocationId: warehouseLocationId,
        search: search,
        isActive: !includeInactive,
      );

      return PaginatedResponse<Equipment>(
        items: response.items.map((dto) => _convertListDtoToEquipment(dto)).toList(),
        page: response.page,
        size: response.perPage,
        totalElements: response.total,
        totalPages: response.totalPages,
        first: response.page == 1,
        last: response.page >= response.totalPages,
      );
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to fetch equipment list: $e');
    }
  }

  // 입고된 장비 목록 조회
  Future<PaginatedResponse<EquipmentListDto>> getEquipmentInList({
    int page = 1,
    int perPage = 20,
    int? companyId,
    int? warehouseLocationId,
    String? search,
  }) async {
    return getEquipmentsWithStatus(
      page: page,
      perPage: perPage,
      status: 'available', // 입고된 장비는 사용 가능 상태
      companyId: companyId,
      warehouseLocationId: warehouseLocationId,
      search: search,
    );
  }

  // 출고된 장비 목록 조회
  Future<PaginatedResponse<EquipmentListDto>> getEquipmentOutList({
    int page = 1,
    int perPage = 20,
    int? companyId,
    int? warehouseLocationId,
    String? search,
  }) async {
    return getEquipmentsWithStatus(
      page: page,
      perPage: perPage,
      status: 'in_use', // 출고된 장비는 사용 중 상태
      companyId: companyId,
      warehouseLocationId: warehouseLocationId,
      search: search,
    );
  }

  // 장비 생성
  Future<Equipment> createEquipment(Equipment equipment) async {
    try {
      final request = CreateEquipmentRequest(
        equipmentNumber: 'EQ-${DateTime.now().millisecondsSinceEpoch}', // 자동 생성 번호
        category1: equipment.category,
        category2: equipment.subCategory,
        category3: equipment.subSubCategory,
        manufacturer: equipment.manufacturer,
        modelName: equipment.name, // 실제 장비명
        serialNumber: equipment.serialNumber,
        barcode: equipment.barcode,
        purchaseDate: equipment.inDate,
        purchasePrice: equipment.purchasePrice,
        companyId: equipment.currentCompanyId,
        warehouseLocationId: equipment.warehouseLocationId,
        lastInspectionDate: equipment.lastInspectionDate,
        nextInspectionDate: equipment.nextInspectionDate,
        remark: equipment.remark,
      );

      final response = await _remoteDataSource.createEquipment(request);
      return _convertResponseToEquipment(response);
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to create equipment: $e');
    }
  }

  // 장비 상세 조회
  Future<Equipment> getEquipmentDetail(int id) async {
    print('DEBUG [EquipmentService.getEquipmentDetail] Called with ID: $id');
    try {
      final response = await _remoteDataSource.getEquipmentDetail(id);
      print('DEBUG [EquipmentService.getEquipmentDetail] Response received from datasource');
      print('DEBUG [EquipmentService.getEquipmentDetail] Response data: ${response.toJson()}');
      
      final equipment = _convertResponseToEquipment(response);
      print('DEBUG [EquipmentService.getEquipmentDetail] Converted to Equipment model');
      print('DEBUG [EquipmentService.getEquipmentDetail] Equipment.manufacturer="${equipment.manufacturer}"');
      print('DEBUG [EquipmentService.getEquipmentDetail] Equipment.name="${equipment.name}"');
      
      return equipment;
    } on ServerException catch (e) {
      print('ERROR [EquipmentService.getEquipmentDetail] ServerException: ${e.message}');
      throw ServerFailure(message: e.message);
    } catch (e, stackTrace) {
      print('ERROR [EquipmentService.getEquipmentDetail] Unexpected error: $e');
      print('ERROR [EquipmentService.getEquipmentDetail] Stack trace: $stackTrace');
      throw ServerFailure(message: 'Failed to fetch equipment detail: $e');
    }
  }
  
  // 장비 조회 (getEquipmentDetail의 alias)
  Future<Equipment> getEquipment(int id) async {
    return getEquipmentDetail(id);
  }

  // 장비 수정
  Future<Equipment> updateEquipment(int id, Equipment equipment) async {
    try {
      final request = UpdateEquipmentRequest(
        category1: equipment.category.isNotEmpty ? equipment.category : null,
        category2: equipment.subCategory.isNotEmpty ? equipment.subCategory : null,
        category3: equipment.subSubCategory.isNotEmpty ? equipment.subSubCategory : null,
        manufacturer: equipment.manufacturer.isNotEmpty ? equipment.manufacturer : null,
        modelName: equipment.name.isNotEmpty ? equipment.name : null, // 실제 장비명
        serialNumber: equipment.serialNumber?.isNotEmpty == true ? equipment.serialNumber : null,
        barcode: equipment.barcode?.isNotEmpty == true ? equipment.barcode : null,
        purchaseDate: equipment.inDate,
        purchasePrice: equipment.purchasePrice,
        status: (equipment.equipmentStatus != null && 
                 equipment.equipmentStatus != 'null' && 
                 equipment.equipmentStatus!.isNotEmpty)
            ? EquipmentStatusConverter.clientToServer(equipment.equipmentStatus) 
            : null,
        companyId: equipment.currentCompanyId,
        warehouseLocationId: equipment.warehouseLocationId,
        lastInspectionDate: equipment.lastInspectionDate,
        nextInspectionDate: equipment.nextInspectionDate,
        remark: equipment.remark?.isNotEmpty == true ? equipment.remark : null,
      );
      
      // 디버그 로그 추가 - 전송되는 데이터 확인
      print('DEBUG [EquipmentService.updateEquipment] Equipment model data:');
      print('  equipment.equipmentStatus: "${equipment.equipmentStatus}"');
      print('  equipment.equipmentStatus type: ${equipment.equipmentStatus.runtimeType}');
      print('  equipment.equipmentStatus == null: ${equipment.equipmentStatus == null}');
      print('  equipment.equipmentStatus == "null": ${equipment.equipmentStatus == "null"}');
      
      String? convertedStatus;
      if (equipment.equipmentStatus != null) {
        convertedStatus = EquipmentStatusConverter.clientToServer(equipment.equipmentStatus);
        print('  converted status: "$convertedStatus"');
      } else {
        print('  status is null, will not set in request');
      }
      
      print('DEBUG [EquipmentService.updateEquipment] Request data:');
      print('  manufacturer: "${request.manufacturer}"');
      print('  modelName: "${request.modelName}"');
      print('  serialNumber: "${request.serialNumber}"');
      print('  status: "${request.status}"');
      print('  companyId: ${request.companyId}');
      print('  warehouseLocationId: ${request.warehouseLocationId}');
      
      // JSON 직렬화 확인
      final jsonData = request.toJson();
      print('DEBUG [EquipmentService.updateEquipment] JSON data:');
      jsonData.forEach((key, value) {
        print('  $key: $value (${value.runtimeType})');
      });

      final response = await _remoteDataSource.updateEquipment(id, request);
      return _convertResponseToEquipment(response);
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to update equipment: $e');
    }
  }

  // 장비 삭제
  Future<void> deleteEquipment(int id) async {
    try {
      await _remoteDataSource.deleteEquipment(id);
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to delete equipment: $e');
    }
  }

  // 장비 상태 변경
  Future<Equipment> changeEquipmentStatus(int id, String status, String? reason) async {
    try {
      final response = await _remoteDataSource.changeEquipmentStatus(id, status, reason);
      return _convertResponseToEquipment(response);
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to change equipment status: $e');
    }
  }

  // 장비 이력 추가
  Future<EquipmentHistoryDto> addEquipmentHistory(int equipmentId, String type, int quantity, String? remarks) async {
    try {
      final request = CreateHistoryRequest(
        transactionType: type,
        quantity: quantity,
        transactionDate: DateTime.now(),
        remarks: remarks,
      );

      return await _remoteDataSource.addEquipmentHistory(equipmentId, request);
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to add equipment history: $e');
    }
  }

  // 장비 이력 조회
  Future<List<EquipmentHistoryDto>> getEquipmentHistory(int equipmentId, {int page = 1, int perPage = 20}) async {
    try {
      return await _remoteDataSource.getEquipmentHistory(equipmentId, page: page, perPage: perPage);
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to fetch equipment history: $e');
    }
  }

  // 장비 입고
  Future<EquipmentIoResponse> equipmentIn({
    required int equipmentId,
    required int quantity,
    int? warehouseLocationId,
    String? notes,
  }) async {
    try {
      final request = EquipmentInRequest(
        equipmentId: equipmentId,
        quantity: quantity,
        warehouseLocationId: warehouseLocationId,
        notes: notes,
      );

      return await _remoteDataSource.equipmentIn(request);
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to process equipment in: $e');
    }
  }

  // 장비 출고
  Future<EquipmentIoResponse> equipmentOut({
    required int equipmentId,
    required int quantity,
    required int companyId,
    String? notes,
  }) async {
    try {
      final request = EquipmentOutRequest(
        equipmentId: equipmentId,
        quantity: quantity,
        companyId: companyId,
        notes: notes,
      );

      return await _remoteDataSource.equipmentOut(request);
    } on ServerException catch (e) {
      throw ServerFailure(message: e.message);
    } catch (e) {
      throw ServerFailure(message: 'Failed to process equipment out: $e');
    }
  }

  // Private helper methods for model conversion
  Equipment _convertListDtoToEquipment(EquipmentListDto dto) {
    return Equipment(
      id: dto.id,
      manufacturer: dto.manufacturer,
      name: dto.modelName ?? '', // modelName이 실제 장비명
      category: '', // Need to be fetched from detail or categories
      subCategory: '',
      subSubCategory: '',
      serialNumber: dto.serialNumber,
      barcode: null, // Not in list DTO
      quantity: 1, // Default quantity
      inDate: dto.createdAt,
      remark: null, // Not in list DTO
      // 백엔드 API 새로운 필드들 (리스트 DTO에서는 제한적)
      currentCompanyId: dto.companyId,
      warehouseLocationId: dto.warehouseLocationId,
      equipmentStatus: dto.status,
    );
  }

  Equipment _convertResponseToEquipment(EquipmentResponse response) {
    print('DEBUG [_convertResponseToEquipment] Converting response to Equipment');
    print('DEBUG [_convertResponseToEquipment] response.manufacturer="${response.manufacturer}"');
    print('DEBUG [_convertResponseToEquipment] response.modelName="${response.modelName}"');
    print('DEBUG [_convertResponseToEquipment] response.category1="${response.category1}"');
    
    final equipment = Equipment(
      id: response.id,
      manufacturer: response.manufacturer,
      name: response.modelName ?? '', // modelName이 실제 장비명
      category: response.category1 ?? '',
      subCategory: response.category2 ?? '',
      subSubCategory: response.category3 ?? '',
      serialNumber: response.serialNumber,
      barcode: response.barcode,
      quantity: 1, // Default quantity, actual quantity should be tracked in history
      inDate: response.purchaseDate,
      remark: response.remark,
      // 백엔드 API 새로운 필드들 매핑
      purchasePrice: response.purchasePrice != null ? double.tryParse(response.purchasePrice!) : null,
      currentCompanyId: response.companyId,
      warehouseLocationId: response.warehouseLocationId,
      lastInspectionDate: response.lastInspectionDate,
      nextInspectionDate: response.nextInspectionDate,
      equipmentStatus: response.status,
      // Warranty information would need to be fetched from license API if available
    );
    
    print('DEBUG [_convertResponseToEquipment] Equipment created');
    print('DEBUG [_convertResponseToEquipment] equipment.manufacturer="${equipment.manufacturer}"');
    print('DEBUG [_convertResponseToEquipment] equipment.name="${equipment.name}"');
    
    return equipment;
  }

  // 장비 상태 상수
  static const Map<String, String> equipmentStatus = {
    'available': '사용 가능',
    'in_use': '사용 중',
    'maintenance': '유지보수 중',
    'repair': '수리 중',
    'disposed': '폐기',
  };
}