sendico/frontend/pshared/lib/provider/payment/wallets.dart

import 'dart:async';
import 'dart:math';

import 'package:flutter/foundation.dart';

import 'package:collection/collection.dart';

import 'package:pshared/models/payment/wallet.dart';
import 'package:pshared/provider/organizations.dart';
import 'package:pshared/provider/resource.dart';
import 'package:pshared/service/payment/wallets.dart';
import 'package:pshared/utils/exception.dart';


class WalletsProvider with ChangeNotifier {
  final WalletsService _service;
  OrganizationsProvider? _organizations;

  WalletsProvider(this._service);

  Resource<List<Wallet>> _resource = Resource(data: []);
  Resource<List<Wallet>> get resource => _resource;

  List<Wallet> get wallets => _resource.data ?? [];
  bool get isLoading => _resource.isLoading;
  Exception? get error => _resource.error;

  bool _isRefreshingBalances = false;
  bool get isRefreshingBalances => _isRefreshingBalances;

  final Set<String> _refreshingWallets = <String>{};
  bool isWalletRefreshing(String walletId) => _refreshingWallets.contains(walletId);

  // Expose current org id so UI controller can reset per-org state if needed.
  String? get organizationId => 
    (_organizations?.isOrganizationSet ?? false) ? _organizations!.current.id : null;

  // Used to ignore stale async results (org changes / overlapping requests).
  int _opSeq = 0;

  // Per-wallet refresh sequence guard.
  final Map<String, int> _walletSeq = <String, int>{};

  // Keep modest concurrency to avoid hammering the backend.
  static const int _balanceConcurrency = 6;

  void update(OrganizationsProvider organizations) {
    _organizations = organizations;
    if (organizations.isOrganizationSet) {
      unawaited(loadWalletsWithBalances());
    }
  }

  Future<Wallet> updateWallet(Wallet newWallet) {
    throw Exception('update wallet is not implemented');
  }

  Future<void> loadWalletsWithBalances() async {
    final org = _organizations;
    if (org == null || !org.isOrganizationSet) return;

    final orgId = org.current.id;
    final seq = ++_opSeq;

    _isRefreshingBalances = false;
    _refreshingWallets.clear();

    _applyResource(_resource.copyWith(isLoading: true, error: null), notify: true);

    try {
      final base = await _service.getWallets(orgId);

      final result = await _withBalances(orgId, base);
      if (seq != _opSeq) return;

      _applyResource(
        Resource<List<Wallet>>(
          data: result.wallets,
          isLoading: false,
          error: result.error,
        ),
        notify: true,
      );
    } catch (e) {
      if (seq != _opSeq) return;

      _applyResource(
        _resource.copyWith(isLoading: false, error: toException(e)),
        notify: true,
      );
    }
  }

  Future<void> refreshBalances() async {
    final org = _organizations;
    if (org == null || !org.isOrganizationSet) return;
    if (wallets.isEmpty) return;

    final orgId = org.current.id;
    final seq = ++_opSeq;

    _isRefreshingBalances = true;
    _applyResource(_resource.copyWith(error: null), notify: false);
    notifyListeners();

    try {
      final result = await _withBalances(orgId, wallets);
      if (seq != _opSeq) return;

      _applyResource(
        _resource.copyWith(data: result.wallets, error: result.error),
        notify: false,
      );
    } catch (e) {
      if (seq != _opSeq) return;

      _applyResource(_resource.copyWith(error: toException(e)), notify: false);
    } finally {
      if (seq == _opSeq) {
        _isRefreshingBalances = false;
        notifyListeners();
      }
    }
  }

  Future<void> refreshBalance(String walletId) async {
    final org = _organizations;
    if (org == null || !org.isOrganizationSet) return;

    if (_refreshingWallets.contains(walletId)) return;

    final existing = wallets.firstWhereOrNull((w) => w.id == walletId);
    if (existing == null) return;

    final orgId = org.current.id;
    final seq = (_walletSeq[walletId] ?? 0) + 1;
    _walletSeq[walletId] = seq;

    _refreshingWallets.add(walletId);
    notifyListeners();

    try {
      final balance = await _service.getBalance(orgId, walletId);
      if ((_walletSeq[walletId] ?? 0) != seq) return;

      final next = _replaceWallet(walletId, (w) => w.copyWith(balance: balance));
      if (next == null) return;

      _applyResource(_resource.copyWith(data: next), notify: false);
    } catch (e) {
      if ((_walletSeq[walletId] ?? 0) != seq) return;

      _applyResource(_resource.copyWith(error: toException(e)), notify: false);
    } finally {
      if ((_walletSeq[walletId] ?? 0) == seq) {
        _refreshingWallets.remove(walletId);
        notifyListeners();
      }
    }
  }

  // ---------- internals ----------

  void _applyResource(Resource<List<Wallet>> newResource, {required bool notify}) {
    _resource = newResource;
    if (notify) notifyListeners();
  }

  List<Wallet>? _replaceWallet(String walletId, Wallet Function(Wallet) updater) {
    final idx = wallets.indexWhere((w) => w.id == walletId);
    if (idx < 0) return null;

    final next = List<Wallet>.from(wallets);
    next[idx] = updater(next[idx]);
    return next;
  }

  Future<_WalletLoadResult> _withBalances(String orgId, List<Wallet> base) async {
    Exception? firstError;

    final withBalances = await _mapConcurrent<Wallet, Wallet>(
      base,
      _balanceConcurrency,
      (wallet) async {
        try {
          final balance = await _service.getBalance(orgId, wallet.id);
          return wallet.copyWith(balance: balance);
        } catch (e) {
          firstError ??= toException(e);
          return wallet;
        }
      },
    );

    return _WalletLoadResult(withBalances, firstError);
  }

  static Future<List<R>> _mapConcurrent<T, R>(
    List<T> items,
    int concurrency,
    Future<R> Function(T) fn,
  ) async {
    if (items.isEmpty) return <R>[];

    final results = List<R?>.filled(items.length, null);
    var nextIndex = 0;

    Future<void> worker() async {
      while (true) {
        final i = nextIndex++;
        if (i >= items.length) return;
        results[i] = await fn(items[i]);
      }
    }

    final workers = List.generate(min(concurrency, items.length), (_) => worker());
    await Future.wait(workers);

    return results.cast<R>();
  }
}

class _WalletLoadResult {
  final List<Wallet> wallets;
  final Exception? error;

  const _WalletLoadResult(this.wallets, this.error);
}