ibit-flutter/lib/providers/deposit_provider.dart

import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../core/network/dio_client.dart';
import '../data/models/asset/recharge_order.dart';
import '../data/models/asset/recharge_record.dart';
import '../data/services/asset_service.dart';
import '../data/services/recharge_service.dart';

// ── On-chain deposit (order flow + WalletConnect) ───────────────────

class DepositState {
  final List<RechargeParentCoin> parentCoins;
  final List<RechargeNetworkItem> networkOptions;
  final List<RechargeConfigOption> subCoinOptions;
  final int selectedParentIndex;
  final int selectedNetworkId;
  final int selectedSubCoinIndex;
  final RechargeOrderDetail? currentOrder;
  final bool loadingParents;
  final bool childrenLoading;
  final bool subCoinsLoading;
  final bool orderSubmitting;
  final bool hashSubmitting;
  final bool walletPayBusy;
  final String? errorMessage;

  const DepositState({
    this.parentCoins = const [],
    this.networkOptions = const [],
    this.subCoinOptions = const [],
    this.selectedParentIndex = 0,
    this.selectedNetworkId = 0,
    this.selectedSubCoinIndex = 0,
    this.currentOrder,
    this.loadingParents = false,
    this.childrenLoading = false,
    this.subCoinsLoading = false,
    this.orderSubmitting = false,
    this.hashSubmitting = false,
    this.walletPayBusy = false,
    this.errorMessage,
  });

  RechargeParentCoin? get selectedParent =>
      parentCoins.isNotEmpty && selectedParentIndex < parentCoins.length
          ? parentCoins[selectedParentIndex]
          : null;

  RechargeConfigOption? get selectedConfig =>
      subCoinOptions.isNotEmpty && selectedSubCoinIndex < subCoinOptions.length
          ? subCoinOptions[selectedSubCoinIndex]
          : null;

  RechargeFlatNetworkOption? get selectedNetwork {
    final cfg = selectedConfig;
    return cfg != null ? RechargeFlatNetworkOption.fromConfig(cfg) : null;
  }

  DepositState copyWith({
    List<RechargeParentCoin>? parentCoins,
    List<RechargeNetworkItem>? networkOptions,
    List<RechargeConfigOption>? subCoinOptions,
    int? selectedParentIndex,
    int? selectedNetworkId,
    int? selectedSubCoinIndex,
    RechargeOrderDetail? currentOrder,
    bool? loadingParents,
    bool? childrenLoading,
    bool? subCoinsLoading,
    bool? orderSubmitting,
    bool? hashSubmitting,
    bool? walletPayBusy,
    String? errorMessage,
    bool clearError = false,
    bool clearOrder = false,
  }) {
    return DepositState(
      parentCoins: parentCoins ?? this.parentCoins,
      networkOptions: networkOptions ?? this.networkOptions,
      subCoinOptions: subCoinOptions ?? this.subCoinOptions,
      selectedParentIndex: selectedParentIndex ?? this.selectedParentIndex,
      selectedNetworkId: selectedNetworkId ?? this.selectedNetworkId,
      selectedSubCoinIndex: selectedSubCoinIndex ?? this.selectedSubCoinIndex,
      currentOrder: clearOrder ? null : (currentOrder ?? this.currentOrder),
      loadingParents: loadingParents ?? this.loadingParents,
      childrenLoading: childrenLoading ?? this.childrenLoading,
      subCoinsLoading: subCoinsLoading ?? this.subCoinsLoading,
      orderSubmitting: orderSubmitting ?? this.orderSubmitting,
      hashSubmitting: hashSubmitting ?? this.hashSubmitting,
      walletPayBusy: walletPayBusy ?? this.walletPayBusy,
      errorMessage: clearError ? null : (errorMessage ?? this.errorMessage),
    );
  }
}

class DepositNotifier extends Notifier<DepositState> {
  @override
  DepositState build() {
    Future.microtask(loadParentCoins);
    return const DepositState(loadingParents: true);
  }

  Future<void> loadParentCoins() async {
    state = state.copyWith(loadingParents: true, clearError: true);
    try {
      final dio = ref.read(dioClientProvider);
      final list = await RechargeService(dio).getRechargeParents();
      var idx = state.selectedParentIndex;
      if (idx >= list.length) {
        idx = 0;
      }
      state = state.copyWith(
        parentCoins: list,
        selectedParentIndex: idx,
        loadingParents: false,
        clearError: true,
      );
      if (list.isNotEmpty) {
        await loadChildrenForParent(list[idx].name);
      } else {
        state = state.copyWith(
          networkOptions: [],
          subCoinOptions: [],
          selectedNetworkId: 0,
          selectedSubCoinIndex: 0,
        );
      }
    } catch (e) {
      state = state.copyWith(
        loadingParents: false,
        errorMessage: e.toString(),
        parentCoins: [],
        networkOptions: [],
        subCoinOptions: [],
      );
    }
  }

  Future<void> loadChildrenForParent(String coinName) async {
    state = state.copyWith(
      childrenLoading: true,
      networkOptions: [],
      subCoinOptions: [],
      selectedNetworkId: 0,
      selectedSubCoinIndex: 0,
      clearError: true,
    );
    try {
      final dio = ref.read(dioClientProvider);
      final service = RechargeService(dio);
      final nets = await service.getRechargeNetworks(coinName: coinName);
      var networkId = state.selectedNetworkId;
      if (nets.isEmpty) {
        networkId = 0;
      } else if (!nets.any((n) => n.id == networkId)) {
        networkId = nets.first.id;
      }
      state = state.copyWith(
        networkOptions: nets,
        selectedNetworkId: networkId,
        selectedSubCoinIndex: 0,
      );
      if (networkId > 0) {
        await _loadSubCoins(coinName, networkId);
      } else {
        state = state.copyWith(
          subCoinOptions: [],
          childrenLoading: false,
          clearError: true,
        );
      }
    } catch (e) {
      state = state.copyWith(
        childrenLoading: false,
        errorMessage: e.toString(),
        networkOptions: [],
        subCoinOptions: [],
      );
    }
  }

  Future<void> _loadSubCoins(String coinName, int networkId) async {
    state = state.copyWith(
      subCoinsLoading: true,
      subCoinOptions: [],
      selectedSubCoinIndex: 0,
      clearError: true,
    );
    try {
      final dio = ref.read(dioClientProvider);
      final configs = await RechargeService(dio).getRechargeConfigs(
        coinName: coinName,
        networkId: networkId,
      );
      var subIdx = state.selectedSubCoinIndex;
      if (subIdx >= configs.length) {
        subIdx = 0;
      }
      state = state.copyWith(
        subCoinOptions: configs,
        selectedSubCoinIndex: subIdx,
        subCoinsLoading: false,
        childrenLoading: false,
        clearError: true,
      );
    } catch (e) {
      state = state.copyWith(
        subCoinsLoading: false,
        childrenLoading: false,
        errorMessage: e.toString(),
        subCoinOptions: [],
      );
    }
  }

  Future<void> selectParent(int index) async {
    if (index < 0 || index >= state.parentCoins.length) {
      return;
    }
    state = state.copyWith(
      selectedParentIndex: index,
      selectedSubCoinIndex: 0,
    );
    final p = state.parentCoins[index];
    await loadChildrenForParent(p.name);
  }

  Future<void> selectNetwork(int networkId) async {
    if (networkId <= 0 ||
        !state.networkOptions.any((n) => n.id == networkId)) {
      return;
    }
    state = state.copyWith(
      selectedNetworkId: networkId,
      selectedSubCoinIndex: 0,
    );
    final parent = state.selectedParent;
    if (parent != null) {
      await _loadSubCoins(parent.name, networkId);
    }
  }

  void selectSubCoin(int index) {
    if (index >= 0 && index < state.subCoinOptions.length) {
      state = state.copyWith(selectedSubCoinIndex: index);
    }
  }

  Future<void> createRechargeOrder(String amount) async {
    final opt = state.selectedConfig;
    if (opt == null) {
      state = state.copyWith(errorMessage: '请先选择充值网络与子币种');
      return;
    }
    state = state.copyWith(orderSubmitting: true, clearError: true);
    try {
      final dio = ref.read(dioClientProvider);
      final order = await RechargeService(dio).createRechargeOrder(
        coinName: opt.coinName,
        networkConfigId: opt.networkConfigId,
        amount: amount,
      );
      state = state.copyWith(
        currentOrder: order,
        orderSubmitting: false,
        clearError: true,
      );
    } catch (e) {
      state = state.copyWith(
        orderSubmitting: false,
        errorMessage: e.toString(),
      );
    }
  }

  Future<void> submitTxHash(String txHash) async {
    final o = state.currentOrder;
    if (o == null || o.orderNo.isEmpty) {
      return;
    }
    state = state.copyWith(hashSubmitting: true, clearError: true);
    try {
      final dio = ref.read(dioClientProvider);
      final updated = await RechargeService(dio).submitTxHash(
        orderNo: o.orderNo,
        txHash: txHash,
      );
      state = state.copyWith(
        currentOrder: updated,
        hashSubmitting: false,
        clearError: true,
      );
    } catch (e) {
      state = state.copyWith(
        hashSubmitting: false,
        errorMessage: e.toString(),
      );
    }
  }

  void clearCurrentOrder() {
    state = state.copyWith(clearOrder: true);
  }

  void setWalletPayBusy(bool v) {
    state = state.copyWith(walletPayBusy: v);
  }

  void clearError() {
    state = state.copyWith(clearError: true);
  }

  Future<void> refresh() => loadParentCoins();
}

final depositProvider =
    NotifierProvider<DepositNotifier, DepositState>(DepositNotifier.new);

// ── Recharge History (legacy list API) ──────────────────────────────

class RechargeHistoryState {
  final List<RechargeRecord> records;
  final bool isLoading;
  final bool hasMore;
  final int currentPage;
  final String? errorMessage;

  const RechargeHistoryState({
    this.records = const [],
    this.isLoading = false,
    this.hasMore = true,
    this.currentPage = 1,
    this.errorMessage,
  });

  RechargeHistoryState copyWith({
    List<RechargeRecord>? records,
    bool? isLoading,
    bool? hasMore,
    int? currentPage,
    String? errorMessage,
  }) =>
      RechargeHistoryState(
        records: records ?? this.records,
        isLoading: isLoading ?? this.isLoading,
        hasMore: hasMore ?? this.hasMore,
        currentPage: currentPage ?? this.currentPage,
        errorMessage: errorMessage,
      );
}

class RechargeHistoryNotifier extends Notifier<RechargeHistoryState> {
  static const _pageSize = 10;

  @override
  RechargeHistoryState build() {
    Future.microtask(_loadFirst);
    return const RechargeHistoryState(isLoading: true);
  }

  Future<void> _loadFirst() async {
    state = state.copyWith(isLoading: true, errorMessage: null);
    try {
      final dio = ref.read(dioClientProvider);
      final records =
          await AssetService(dio).getRechargeList(pageNo: 1, pageSize: _pageSize);
      state = state.copyWith(
        records: records,
        isLoading: false,
        currentPage: 1,
        hasMore: records.length >= _pageSize,
      );
    } catch (e) {
      state = state.copyWith(isLoading: false, errorMessage: e.toString());
    }
  }

  Future<void> refresh() => _loadFirst();

  Future<void> loadMore() async {
    if (state.isLoading || !state.hasMore) {
      return;
    }
    state = state.copyWith(isLoading: true);
    try {
      final nextPage = state.currentPage + 1;
      final dio = ref.read(dioClientProvider);
      final records = await AssetService(dio)
          .getRechargeList(pageNo: nextPage, pageSize: _pageSize);
      state = state.copyWith(
        records: [...state.records, ...records],
        isLoading: false,
        currentPage: nextPage,
        hasMore: records.length >= _pageSize,
      );
    } catch (e) {
      state = state.copyWith(isLoading: false, errorMessage: e.toString());
    }
  }
}

final rechargeHistoryProvider =
    NotifierProvider<RechargeHistoryNotifier, RechargeHistoryState>(
  RechargeHistoryNotifier.new,
);