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/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,
        includeInactive: 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,
        includeInactive: 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,
        purchaseDate: equipment.inDate,
        purchasePrice: null, // 가격 정보는 별도 관리
        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,
        category2: equipment.subCategory,
        category3: equipment.subSubCategory,
        manufacturer: equipment.manufacturer,
        modelName: equipment.name, // 실제 장비명
        serialNumber: equipment.serialNumber,
        barcode: equipment.barcode,
        purchaseDate: equipment.inDate,
        purchasePrice: null, // 가격 정보는 별도 관리
        remark: equipment.remark,
      );

      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,
    int? branchId,
    String? notes,
  }) async {
    try {
      final request = EquipmentOutRequest(
        equipmentId: equipmentId,
        quantity: quantity,
        companyId: companyId,
        branchId: branchId,
        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
    );
  }

  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,
      // 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': '폐기',
  };
}