import 'package:flutter/material.dart';
import 'package:get_it/get_it.dart';
import 'package:superport/models/equipment_unified_model.dart';
import 'package:superport/services/equipment_service.dart';
import 'package:superport/services/warehouse_service.dart';
import 'package:superport/services/company_service.dart';
import 'package:superport/utils/constants.dart';
import 'package:superport/core/errors/failures.dart';
import 'package:superport/core/utils/debug_logger.dart';
import 'package:superport/core/utils/equipment_status_converter.dart';
import 'package:superport/core/services/lookups_service.dart';

/// 장비 입고 폼 컨트롤러
///
/// 폼의 전체 상태, 유효성, 저장, 데이터 로딩 등 비즈니스 로직을 담당한다.
class EquipmentInFormController extends ChangeNotifier {
  final EquipmentService _equipmentService = GetIt.instance<EquipmentService>();
  final WarehouseService _warehouseService = GetIt.instance<WarehouseService>();
  final CompanyService _companyService = GetIt.instance<CompanyService>();
  final LookupsService _lookupsService = GetIt.instance<LookupsService>();
  final int? equipmentInId; // 실제로는 장비 ID (입고 ID가 아님)
  int? actualEquipmentId; // API 호출용 실제 장비 ID
  
  bool _isLoading = false;
  String? _error;
  bool _isSaving = false;
  // API만 사용
  
  // Getters
  bool get isLoading => _isLoading;
  String? get error => _error;
  bool get isSaving => _isSaving;
  
  // 저장 가능 상태를 별도 변수로 관리 (성능 개선 및 UI 동기화)
  bool _canSave = false;
  bool get canSave => _canSave;
  
  /// canSave 상태 업데이트 (UI 렌더링 문제 해결)
  void _updateCanSave() {
    final hasEquipmentNumber = _equipmentNumber.trim().isNotEmpty;
    final hasManufacturer = _manufacturer.trim().isNotEmpty;
    final isNotSaving = !_isSaving;
    
    final newCanSave = isNotSaving && hasEquipmentNumber && hasManufacturer;
    
    if (_canSave != newCanSave) {
      _canSave = newCanSave;
      print('🚀 [canSave 상태 변경] $_canSave → equipmentNumber: "$_equipmentNumber", manufacturer: "$_manufacturer"');
      notifyListeners(); // 명시적 UI 업데이트
    }
  }

  // 폼 키
  final GlobalKey<FormState> formKey = GlobalKey<FormState>();

  // 입력 상태 변수 (백엔드 API 구조에 맞게 수정)
  String _equipmentNumber = ''; // 장비번호 (필수) - private으로 변경
  String _manufacturer = '';    // 제조사 (필수) - private으로 변경
  String _modelName = '';       // 모델명 - private으로 변경
  String _serialNumber = '';    // 시리얼번호 - private으로 변경
  String _category1 = '';       // 대분류 - private으로 변경
  String _category2 = '';       // 중분류 - private으로 변경
  String _category3 = '';       // 소분류 - private으로 변경

  // Getters and Setters for reactive fields
  String get equipmentNumber => _equipmentNumber;
  set equipmentNumber(String value) {
    if (_equipmentNumber != value) {
      _equipmentNumber = value;
      _updateCanSave(); // canSave 상태 업데이트
      print('DEBUG [Controller] equipmentNumber updated: "$_equipmentNumber"');
    }
  }

  String get serialNumber => _serialNumber;
  set serialNumber(String value) {
    if (_serialNumber != value) {
      _serialNumber = value;
      _updateCanSave(); // canSave 상태 업데이트
      print('DEBUG [Controller] serialNumber updated: "$_serialNumber"');
    }
  }

  String get manufacturer => _manufacturer;
  set manufacturer(String value) {
    if (_manufacturer != value) {
      _manufacturer = value;
      _updateCanSave(); // canSave 상태 업데이트
      print('DEBUG [Controller] manufacturer updated: "$_manufacturer"');
    }
  }

  String get modelName => _modelName;
  set modelName(String value) {
    if (_modelName != value) {
      _modelName = value;
      _updateCanSave(); // canSave 상태 업데이트
      print('DEBUG [Controller] modelName updated: "$_modelName"');
    }
  }

  String get category1 => _category1;
  set category1(String value) {
    if (_category1 != value) {
      _category1 = value;
      _updateCanSave(); // canSave 상태 업데이트
    }
  }

  String get category2 => _category2;
  set category2(String value) {
    if (_category2 != value) {
      _category2 = value;
      _updateCanSave(); // canSave 상태 업데이트
    }
  }

  String get category3 => _category3;
  set category3(String value) {
    if (_category3 != value) {
      _category3 = value;
      _updateCanSave(); // canSave 상태 업데이트
    }
  }
  DateTime? purchaseDate;      // 구매일
  double? purchasePrice;       // 구매가격
  
  // 삭제된 필드들 (백엔드 미지원)
  // barcode, quantity, inDate, equipmentType, hasSerialNumber
  // warranty 관련 모든 필드들

  // Lookups API 데이터 (매번 API 호출)
  List<String> manufacturers = [];
  List<String> equipmentNames = [];
  Map<int, String> companies = {};
  Map<int, String> warehouses = {};
  
  // 선택된 ID 값들
  int? selectedCompanyId;      // 구매처 ID
  int? selectedWarehouseId;    // 입고지 ID
  
  // 창고 위치 전체 데이터 (이름-ID 매핑용)
  Map<String, int> warehouseLocationMap = {};

  // 편집 모드 여부
  bool isEditMode = false;

  // 수정불가 필드 목록 (수정 모드에서만 적용)
  static const List<String> _readOnlyFields = [
    'equipmentNumber',  // 장비번호
    'manufacturer',     // 제조사
    'modelName',        // 모델명
    'serialNumber',     // 시리얼번호
    'purchaseDate',     // 구매일
    'purchasePrice',    // 구매가격
  ];

  /// 특정 필드가 수정불가인지 확인
  bool isFieldReadOnly(String fieldName) {
    return isEditMode && _readOnlyFields.contains(fieldName);
  }

  // 입고지, 파트너사 관련 상태
  String? warehouseLocation;
  String? partnerCompany;
  List<String> warehouseLocations = [];
  List<String> partnerCompanies = [];

  // 기존 필드들은 위로 이동, 삭제된 필드들
  // currentCompanyId, currentBranchId, lastInspectionDate, nextInspectionDate, equipmentStatus는 입고 시 불필요
  
  // 워런티 관련 필드들 (필요 시 사용)
  String? warrantyLicense;
  DateTime warrantyStartDate = DateTime.now();
  DateTime warrantyEndDate = DateTime.now().add(const Duration(days: 365));

  final TextEditingController remarkController = TextEditingController();

  EquipmentInFormController({this.equipmentInId}) {
    isEditMode = equipmentInId != null;
    _loadDropdownData();
    _updateCanSave(); // 초기 canSave 상태 설정
    // 수정 모드일 때 초기 데이터 로드는 initializeForEdit() 메서드로 이동
  }

  // 수정 모드 초기화 (외부에서 호출)
  Future<void> initializeForEdit() async {
    if (!isEditMode || equipmentInId == null) return;
    await _loadEquipmentIn();
  }

  // 드롭다운 데이터 로드 (매번 API 호출)
  void _loadDropdownData() async {
    try {
      DebugLogger.log('Equipment 폼 드롭다운 데이터 로드 시작', tag: 'EQUIPMENT_IN');
      final result = await _lookupsService.getEquipmentFormDropdownData();
      
      result.fold(
        (failure) {
          DebugLogger.logError('드롭다운 데이터 로드 실패', error: failure.message);
          // API 실패 시 빈 데이터
          manufacturers = [];
          equipmentNames = [];
          companies = {};
          warehouses = {};
          notifyListeners();
        },
        (data) {
          manufacturers = data['manufacturers'] as List<String>;
          equipmentNames = data['equipment_names'] as List<String>;
          companies = data['companies'] as Map<int, String>;
          warehouses = data['warehouses'] as Map<int, String>;
          
          DebugLogger.log('드롭다운 데이터 로드 성공', tag: 'EQUIPMENT_IN', data: {
            'manufacturers_count': manufacturers.length,
            'equipment_names_count': equipmentNames.length,
            'companies_count': companies.length,
            'warehouses_count': warehouses.length,
          });
          
          notifyListeners();
        },
      );
    } catch (e) {
      DebugLogger.logError('드롭다운 데이터 로드 예외', error: e);
      manufacturers = [];
      equipmentNames = [];
      companies = {};
      warehouses = {};
      notifyListeners();
    }
  }

  // 기존의 개별 로드 메서드들은 _loadDropdownData()로 통합됨
  // warehouseLocations, partnerCompanies 리스트 변수들도 제거됨

  // 기존 데이터 로드(수정 모드)
  Future<void> _loadEquipmentIn() async {
    if (equipmentInId == null) return;
    
    _isLoading = true;
    _error = null;
    notifyListeners();
    
    try {
      // equipmentInId는 실제로 장빔 ID임 (입고 ID가 아님)
      actualEquipmentId = equipmentInId;
      
      try {
        // API에서 장비 정보 가져오기
          print('DEBUG [_loadEquipmentIn] Start loading equipment ID: $actualEquipmentId');
          DebugLogger.log('장비 정보 로드 시작', tag: 'EQUIPMENT_IN', data: {
            'equipmentId': actualEquipmentId,
          });
          
          final equipment = await _equipmentService.getEquipmentDetail(actualEquipmentId!);
          print('DEBUG [_loadEquipmentIn] Equipment loaded from service');
          
          print('DEBUG [_loadEquipmentIn] Equipment loaded successfully');
          DebugLogger.log('장비 정보 로드 성공', tag: 'EQUIPMENT_IN', data: {
            'equipmentId': equipment.id,
            'manufacturer': equipment.manufacturer,
            'equipmentNumber': equipment.equipmentNumber, // name → equipmentNumber
          });
          
          // 장비 정보 설정 (새로운 필드 구조)
          print('DEBUG [_loadEquipmentIn] Setting equipment data...');
          print('DEBUG [_loadEquipmentIn] equipment.manufacturer="${equipment.manufacturer}"');
          print('DEBUG [_loadEquipmentIn] equipment.equipmentNumber="${equipment.equipmentNumber}"');
          
          // 새로운 필드 구조로 매핑 (setter 사용하여 notifyListeners 자동 호출)
          _equipmentNumber = equipment.equipmentNumber ?? '';
          manufacturer = equipment.manufacturer ?? '';
          modelName = equipment.modelName ?? ''; // deprecated name 제거
          _serialNumber = equipment.serialNumber ?? '';
          category1 = equipment.category1 ?? ''; // deprecated category 제거
          category2 = equipment.category2 ?? ''; // deprecated subCategory 제거
          category3 = equipment.category3 ?? ''; // deprecated subSubCategory 제거
          purchaseDate = equipment.purchaseDate;
          purchasePrice = equipment.purchasePrice;
          selectedCompanyId = equipment.companyId;
          selectedWarehouseId = equipment.warehouseLocationId;
          remarkController.text = equipment.remark ?? '';
          
          print('DEBUG [_loadEquipmentIn] After setting - equipmentNumber="$_equipmentNumber", manufacturer="$_manufacturer", modelName="$_modelName"');
          // 🔧 [DEBUG] UI 업데이트를 위한 중요 필드들 로깅
          print('DEBUG [_loadEquipmentIn] purchaseDate: $purchaseDate, purchasePrice: $purchasePrice');
          print('DEBUG [_loadEquipmentIn] selectedCompanyId: $selectedCompanyId, selectedWarehouseId: $selectedWarehouseId');
          
          DebugLogger.log('장비 데이터 설정 완료', tag: 'EQUIPMENT_IN', data: {
            'equipmentNumber': _equipmentNumber,
            'manufacturer': _manufacturer,
            'modelName': _modelName,
            'category1': _category1,
            'category2': _category2,
            'category3': _category3,
            'serialNumber': _serialNumber,
          });
          
          print('DEBUG [EQUIPMENT_IN]: Equipment loaded - equipmentNumber: "$_equipmentNumber", manufacturer: "$_manufacturer", modelName: "$_modelName"');
          
          // 추가 필드들은 입고 시에는 필요하지 않으므로 생략
          
        } catch (e, stackTrace) {
          print('DEBUG [_loadEquipmentIn] Error loading equipment: $e');
          print('DEBUG [_loadEquipmentIn] Stack trace: $stackTrace');
          DebugLogger.logError('장비 정보 로드 실패', error: e);
          throw ServerFailure(message: '장비 정보를 찾을 수 없습니다.');
        }
    } catch (e) {
      _error = '장비 정보를 불러오는데 실패했습니다: $e';
      DebugLogger.logError('장비 로드 실패', error: e);
    } finally {
      _isLoading = false;
      _updateCanSave(); // 데이터 로드 완료 시 canSave 상태 업데이트
      notifyListeners();
    }
  }
  

  // 워런티 기간 계산
  String getWarrantyPeriodSummary() {
    final difference = warrantyEndDate.difference(warrantyStartDate);
    final days = difference.inDays;

    if (days <= 0) {
      return '유효하지 않은 기간';
    }

    final years = days ~/ 365;
    final remainingDays = days % 365;

    String summary = '';
    if (years > 0) {
      summary += '$years년 ';
    }
    if (remainingDays > 0) {
      summary += '$remainingDays일';
    }

    return summary.trim();
  }

  // 저장 처리
  Future<bool> save() async {
    if (!formKey.currentState!.validate()) {
      return false;
    }
    formKey.currentState!.save();
    
    _isSaving = true;
    _error = null;
    _updateCanSave(); // 저장 시작 시 canSave 상태 업데이트
    notifyListeners();
    
    try {

      // 새로운 입력값을 로컬 리스트에 추가 (사용자 경험 향상용)
      if (_manufacturer.isNotEmpty && !manufacturers.contains(_manufacturer)) {
        manufacturers.add(_manufacturer);
      }
      if (_modelName.isNotEmpty && !equipmentNames.contains(_modelName)) {
        equipmentNames.add(_modelName);
      }

    // 백엔드 API 구조에 맞는 Equipment 객체 생성
    final equipment = Equipment(
      // Required 필드들
      manufacturer: _manufacturer.trim(),
      equipmentNumber: _equipmentNumber.trim(), // required
      modelName: _modelName.trim().isEmpty ? _equipmentNumber.trim() : _modelName.trim(), // required
      category1: _category1.trim().isEmpty ? 'N/A' : _category1.trim(), // required (nullable에서 non-nullable로)
      category2: _category2.trim().isEmpty ? 'N/A' : _category2.trim(), // required (nullable에서 non-nullable로)
      category3: _category3.trim().isEmpty ? 'N/A' : _category3.trim(), // required (nullable에서 non-nullable로)
      quantity: 1, // required
      // Optional 필드들
      serialNumber: _serialNumber.trim().isEmpty ? null : _serialNumber.trim(),
      purchaseDate: purchaseDate,
      purchasePrice: purchasePrice,
      inDate: purchaseDate ?? DateTime.now(),
      remark: remarkController.text.trim().isEmpty ? null : remarkController.text.trim(),
      companyId: selectedCompanyId,      // 구매처 ID
      warehouseLocationId: selectedWarehouseId, // 입고지 ID
      barcode: '', // 사용하지 않음
    );
    
    // API 호출
    if (isEditMode) {
        // 수정 모드 - API로 장비 정보 업데이트
        if (actualEquipmentId == null) {
          throw ServerFailure(message: '장비 ID가 없습니다.');
        }
        
        DebugLogger.log('장비 정보 업데이트 시작', tag: 'EQUIPMENT_IN', data: {
          'equipmentId': actualEquipmentId,
          'equipmentNumber': equipment.equipmentNumber,
          'manufacturer': equipment.manufacturer,
          'modelName': equipment.modelName,
          'serialNumber': equipment.serialNumber,
        });
        
        await _equipmentService.updateEquipment(actualEquipmentId!, equipment);
        
        DebugLogger.log('장비 정보 업데이트 성공', tag: 'EQUIPMENT_IN');
      } else {
        // 생성 모드
        try {
          // 1. 먼저 장비 생성
          DebugLogger.log('장비 입고 시작', tag: 'EQUIPMENT_IN', data: {
            'equipmentNumber': _equipmentNumber,
            'manufacturer': _manufacturer,
            'modelName': _modelName,
            'serialNumber': _serialNumber,
          });
          
          final createdEquipment = await _equipmentService.createEquipment(equipment);
          
          DebugLogger.log('장비 생성 성공', tag: 'EQUIPMENT_IN', data: {
            'equipmentId': createdEquipment.id,
          });
          
          // 새로운 API에서는 장비 생성 시 입고 처리까지 한 번에 처리됨
          
          DebugLogger.log('입고 처리 성공', tag: 'EQUIPMENT_IN');
          
        } catch (e) {
          DebugLogger.logError('장비 입고 처리 실패', error: e);
          throw e;  // 에러를 상위로 전파하여 적절한 에러 메시지 표시
        }
      }

    // 저장 후 드롭다운 데이터 새로고침 (백엔드 데이터 업데이트를 위해)
    _loadDropdownData();

    return true;
    } on Failure catch (e) {
      _error = e.message;
      notifyListeners();
      return false;
    } catch (e) {
      _error = 'An unexpected error occurred: $e';
      notifyListeners();
      return false;
    } finally {
      _isSaving = false;
      _updateCanSave(); // 저장 완료 시 canSave 상태 업데이트
      notifyListeners();
    }
  }

  // 에러 처리
  void clearError() {
    _error = null;
    notifyListeners();
  }
  
  // API만 사용하므로 토글 기능 제거
  
  @override
  void dispose() {
    remarkController.dispose();
    super.dispose();
  }
}
