import 'package:flutter_riverpod/flutter_riverpod.dart';
import '../models/work_order.dart';
import '../services/api_service.dart';

class WorkOrderState {
  final List<WorkOrder> orders;
  final bool isLoading;
  final String? error;

  const WorkOrderState({this.orders = const [], this.isLoading = false, this.error});

  WorkOrderState copyWith({List<WorkOrder>? orders, bool? isLoading, String? error}) {
    return WorkOrderState(
      orders: orders ?? this.orders,
      isLoading: isLoading ?? this.isLoading,
      error: error,
    );
  }
}

class WorkOrderNotifier extends StateNotifier<WorkOrderState> {
  WorkOrderNotifier() : super(const WorkOrderState());

  Future<void> loadOrders(WorkOrderStatus status) async {
    state = state.copyWith(isLoading: true, error: null);
    try {
      final orders = await apiService.getWorkOrders(status);
      state = state.copyWith(orders: orders, isLoading: false);
    } catch (e) {
      state = state.copyWith(isLoading: false, error: e.toString());
    }
  }

  Future<WorkOrder?> getDetail(String id) async {
    try {
      final order = await apiService.getWorkOrderDetail(id);
      _upsertOrder(order);
      return order;
    } catch (_) {
      return null;
    }
  }

  Future<bool> acceptOrder(String id) async {
    try {
      final updated = await apiService.acceptWorkOrder(id);
      _upsertOrder(updated);
      return true;
    } catch (_) {
      return false;
    }
  }

  Future<bool> transferOrder(String id, String department) async {
    try {
      final updated = await apiService.transferWorkOrder(id, department);
      _upsertOrder(updated);
      return true;
    } catch (_) {
      return false;
    }
  }

  Future<bool> completeOrder(String id) async {
    try {
      final updated = await apiService.completeWorkOrder(id);
      _upsertOrder(updated);
      return true;
    } catch (_) {
      return false;
    }
  }

  void _upsertOrder(WorkOrder order) {
    final exists = state.orders.any((o) => o.id == order.id);
    final newOrders = exists
        ? state.orders.map((o) => o.id == order.id ? order : o).toList()
        : [...state.orders, order];
    state = state.copyWith(orders: newOrders);
  }
}

final workOrderProvider = StateNotifierProvider<WorkOrderNotifier, WorkOrderState>((ref) {
  return WorkOrderNotifier();
});