GrowthTrack Mobile

// Estado asíncrono de campañas con Riverpod — AsyncNotifier + caché Hive
import 'package:flutter_riverpod/flutter_riverpod.dart';
import '../models/campaign.dart';
import '../repositories/campaign_repository.dart';

// Modelo Freezed — inmutable, serializable
@freezed
class Campaign with _$Campaign {
  const factory Campaign({
    required String  id,
    required String  name,
    required double  roas,
    required double  dailyBudget,
    required bool    isActive,
    required int     impressions,
    required int     leads,
  }) = _Campaign;

  factory Campaign.fromJson(Map<String, dynamic> json) => _$CampaignFromJson(json);
}

// AsyncNotifier — maneja loading / data / error automáticamente
class CampaignsNotifier extends AsyncNotifier<List<Campaign>> {
  @override
  Future<List<Campaign>> build() async {
    final repo = ref.read(campaignRepositoryProvider);
    final cached = await repo.getCached();        // Hive — respuesta instantánea
    if (cached.isNotEmpty) state = AsyncData(cached);
    return repo.fetchAll();                        // API — actualiza en background
  }

  /// Actualiza el presupuesto diario de una campaña (optimistic update)
  Future<void> updateBudget(String id, double newBudget) async {
    final prev = state.value ?? [];
    state = AsyncData(prev.map((c) =>
      c.id == id ? c.copyWith(dailyBudget: newBudget) : c
    ).toList());
    try {
      await ref.read(campaignRepositoryProvider).updateBudget(id, newBudget);
    } catch (e) {
      state = AsyncData(prev);            // Rollback si la API falla
      rethrow;
    }
  }
}

final campaignsProvider =
  AsyncNotifierProvider<CampaignsNotifier, List<Campaign>>(CampaignsNotifier.new);

// Rutas declarativas con redirección por auth y ShellRoute de navegación
import 'package:go_router/go_router.dart';

final router = GoRouter(
  initialLocation: '/',
  redirect: (context, state) {
    final auth = providerContainer.read(authProvider);
    final isLoggedIn = auth.user != null;
    final onAuth    = state.matchedLocation.startsWith('/auth');
    if (!isLoggedIn && !onAuth) return '/auth/login';
    if (isLoggedIn  &&  onAuth) return '/';
    return null;
  },
  routes: [
    GoRoute(path: '/auth/login',  builder: (_, __) => const LoginScreen()),
    // Shell con barra de navegación inferior compartida
    ShellRoute(
      builder: (_, __, child) => AppShell(child: child),
      routes: [
        GoRoute(path: '/',          builder: (_, __) => const DashboardScreen()),
        GoRoute(path: '/campaigns', builder: (_, __) => const CampaignListScreen()),
        GoRoute(
          path: '/campaigns/:id',
          builder: (_, s) => CampaignDetailScreen(id: s.pathParameters['id']!),
        ),
        GoRoute(path: '/settings',  builder: (_, __) => const SettingsScreen()),
      ],
    ),
  ],
);

// Autenticación biométrica vía MethodChannel — Face ID (iOS) / Huella (Android)
import 'package:flutter/services.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

class BiometricService {
  static const _channel = MethodChannel('io.growthtrack/biometric');

  /// Devuelve true si el dispositivo soporta biometría
  Future<bool> isAvailable() async {
    try {
      return await _channel.invokeMethod<bool>('isAvailable') ?? false;
    } on PlatformException {
      return false;
    }
  }

  /// Muestra el prompt de Face ID / huella y devuelve si fue exitosa
  Future<bool> authenticate({required String reason}) async {
    try {
      return await _channel.invokeMethod<bool>(
        'authenticate', {'reason': reason},
      ) ?? false;
    } on PlatformException catch (e) {
      throw AuthException(e.message ?? 'Biometric failed');
    }
  }
}

// Provider global
final biometricServiceProvider = Provider((ref) => BiometricService());