import 'package:drift/drift.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import '../database/database.dart';
import '../../business/order_manager.dart';
import 'database_provider.dart';

class OrderState {
  final Ordine? order;
  final List<RigaOrdine> lines;
  final bool isLoading;
  final String? error;

  const OrderState({this.order, this.lines = const [], this.isLoading = false, this.error});

  double get totale {
    return lines.fold(0.0, (sum, l) => sum + (l.totale ?? 0));
  }

  double get totQta {
    return lines.fold(0.0, (sum, l) => sum + (l.quantita ?? 0));
  }
}

class OrderNotifier extends Notifier<OrderState> {
  @override
  OrderState build() => const OrderState();

  OrderManager _buildManager() {
    return OrderManager(
      ref.read(ordiniDaoProvider),
      ref.read(clientiDaoProvider),
      ref.read(filialiDaoProvider),
      ref.read(articoliDaoProvider),
      ref.read(listiniDaoProvider),
      ref.read(scontiDaoProvider),
      ref.read(pagamentiDaoProvider),
      ref.read(agentiDaoProvider),
    );
  }

  Future<void> createOrder(int idAgente, {int? idCliente}) async {
    final mgr = _buildManager();
    mgr.idAgente = idAgente;
    final order = await mgr.createOrder(idCliente: idCliente);
    state = OrderState(order: order);
  }

  Future<void> loadOrder(int id) async {
    state = const OrderState(isLoading: true);
    final mgr = _buildManager();
    final order = await mgr.loadOrder(id);
    if (order != null) {
      final lines = await mgr.getOrderLines(id);
      state = OrderState(order: order, lines: lines);
    } else {
      state = const OrderState(error: 'Ordine non trovato');
    }
  }

  void setIdCliente(int idCliente) {
    if (state.order == null) return;
    state = OrderState(
      order: state.order!.copyWith(idCliente: Value<int?>(idCliente)),
      lines: state.lines,
    );
  }

  Future<void> addLine(RigaOrdine line) async {
    if (state.order == null) return;
    final dao = ref.read(ordiniDaoProvider);
    await dao.insertOrderLine(line.copyWith(idOrdine: Value<int?>(state.order!.idOrdine)));
    final lines = await dao.getOrderLines(state.order!.idOrdine);
    state = OrderState(order: state.order, lines: lines);
  }

  Future<void> editLine(RigaOrdine line) async {
    if (state.order == null) return;
    final dao = ref.read(ordiniDaoProvider);
    await dao.updateOrderLine(line);
    final lines = await dao.getOrderLines(state.order!.idOrdine);
    state = OrderState(order: state.order, lines: lines);
  }

  Future<void> removeLine(int idRigaOrdine) async {
    if (state.order == null) return;
    final dao = ref.read(ordiniDaoProvider);
    await dao.deleteOrderLine(idRigaOrdine);
    final lines = await dao.getOrderLines(state.order!.idOrdine);
    state = OrderState(order: state.order, lines: lines);
  }

  Future<void> saveOrder() async {
    if (state.order == null) return;
    final mgr = _buildManager();
    mgr.idAgente = state.order!.idAgente ?? 0;
    mgr.setCurrentOrder(state.order!);
    await mgr.saveOrder();
    final updated = mgr.currentOrder;
    state = OrderState(order: updated, lines: state.lines);
  }

  Future<void> deleteOrder() async {
    if (state.order == null) return;
    final dao = ref.read(ordiniDaoProvider);
    await dao.deleteOrder(state.order!.idOrdine);
    state = const OrderState();
  }

  void setIdFiliale(int? v) {
    if (state.order == null) return;
    state = OrderState(
      order: state.order!.copyWith(idFiliale: Value<int?>(v)),
      lines: state.lines,
    );
  }

  void setIdListino(int? v) {
    if (state.order == null) return;
    state = OrderState(
      order: state.order!.copyWith(idListino: Value<int?>(v)),
      lines: state.lines,
    );
  }

  void setIdPagamento(int? v) {
    if (state.order == null) return;
    state = OrderState(
      order: state.order!.copyWith(idPagamento: Value<int?>(v)),
      lines: state.lines,
    );
  }

  void setNoteCliente(String? v) {
    if (state.order == null) return;
    state = OrderState(
      order: state.order!.copyWith(noteCliente: Value<String?>(v)),
      lines: state.lines,
    );
  }

  void setNoteOrdine(String? v) {
    if (state.order == null) return;
    state = OrderState(
      order: state.order!.copyWith(noteOrdine: Value<String?>(v)),
      lines: state.lines,
    );
  }

  void setRiferimento(String? v) {
    if (state.order == null) return;
    state = OrderState(
      order: state.order!.copyWith(riferimento: Value<String?>(v)),
      lines: state.lines,
    );
  }
}

final orderProvider = NotifierProvider<OrderNotifier, OrderState>(OrderNotifier.new);

final ordersViewProvider = FutureProvider.family<List<VOrdiniData>, int>((ref, idAgente) {
  return ref.read(ordiniDaoProvider).getOrdersView(idAgente);
});

final ordersSearchViewProvider = FutureProvider.family<List<VOrdiniData>, ({int idAgente, String filter})>(
  (ref, params) {
    return ref.read(ordiniDaoProvider).searchOrdersView(params.idAgente, params.filter);
  },
);

class OrderStats {
  final int daTrasmettere;
  final int numeroOrdini;
  final double volumeMensile;

  const OrderStats({
    this.daTrasmettere = 0,
    this.numeroOrdini = 0,
    this.volumeMensile = 0,
  });
}

final orderStatsProvider = FutureProvider.family<OrderStats, int>((ref, idAgente) async {
  final dao = ref.read(ordiniDaoProvider);
  final daTrasmettere = await dao.countNewOrdersForAgent(idAgente);
  final numeroOrdini = await dao.countOrdersForAgent(idAgente);
  final volumeMensile = await dao.getMonthlyVolume(idAgente);
  return OrderStats(
    daTrasmettere: daTrasmettere,
    numeroOrdini: numeroOrdini,
    volumeMensile: volumeMensile,
  );
});