import 'package:dio/dio.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:hive_ce/hive.dart';

import '../../../../core/network/api_client.dart';
import '../../data/datasources/scanner_local_datasource.dart';
import '../../data/datasources/scanner_remote_datasource.dart';
import '../../data/models/scan_item.dart';
import '../../data/repositories/scanner_repository_impl.dart';
import '../../domain/repositories/scanner_repository.dart';
import '../../domain/usecases/get_scan_history_usecase.dart';
import '../../domain/usecases/save_scan_usecase.dart';

/// Network layer providers
final dioProvider = Provider<Dio>((ref) {
  final dio = Dio();
  dio.options.baseUrl = 'https://api.example.com'; // Replace with actual API URL
  dio.options.connectTimeout = const Duration(seconds: 30);
  dio.options.receiveTimeout = const Duration(seconds: 30);
  dio.options.headers['Content-Type'] = 'application/json';
  dio.options.headers['Accept'] = 'application/json';

  // Add interceptors for logging, authentication, etc.
  dio.interceptors.add(
    LogInterceptor(
      requestBody: true,
      responseBody: true,
      logPrint: (obj) {
        // Log to console in debug mode using debugPrint
        // This will only log in debug mode
      },
    ),
  );

  return dio;
});

final apiClientProvider = Provider<ApiClient>((ref) {
  return ApiClient();
});

/// Local storage providers
final hiveBoxProvider = Provider<Box<ScanItem>>((ref) {
  return Hive.box<ScanItem>('scans');
});

/// Settings box provider
final settingsBoxProvider = Provider<Box>((ref) {
  return Hive.box('settings');
});

/// Data source providers
final scannerRemoteDataSourceProvider = Provider<ScannerRemoteDataSource>((ref) {
  return ScannerRemoteDataSourceImpl(apiClient: ref.watch(apiClientProvider));
});

final scannerLocalDataSourceProvider = Provider<ScannerLocalDataSource>((ref) {
  return ScannerLocalDataSourceImpl();
});

/// Repository providers
final scannerRepositoryProvider = Provider<ScannerRepository>((ref) {
  return ScannerRepositoryImpl(
    remoteDataSource: ref.watch(scannerRemoteDataSourceProvider),
    localDataSource: ref.watch(scannerLocalDataSourceProvider),
  );
});

/// Use case providers
final saveScanUseCaseProvider = Provider<SaveScanUseCase>((ref) {
  return SaveScanUseCase(ref.watch(scannerRepositoryProvider));
});

final getScanHistoryUseCaseProvider = Provider<GetScanHistoryUseCase>((ref) {
  return GetScanHistoryUseCase(ref.watch(scannerRepositoryProvider));
});

/// Additional utility providers
final currentTimestampProvider = Provider<DateTime>((ref) {
  return DateTime.now();
});

/// Provider for checking network connectivity
final networkStatusProvider = Provider<bool>((ref) {
  // This would typically use connectivity_plus package
  // For now, returning true as a placeholder
  return true;
});

/// Provider for app configuration
final appConfigProvider = Provider<Map<String, dynamic>>((ref) {
  return {
    'apiBaseUrl': 'https://api.example.com',
    'apiTimeout': 30000,
    'maxHistoryItems': 100,
    'enableLogging': !const bool.fromEnvironment('dart.vm.product'),
  };
});

/// Provider for error handling configuration
final errorHandlingConfigProvider = Provider<Map<String, String>>((ref) {
  return {
    'networkError': 'Network connection failed. Please check your internet connection.',
    'serverError': 'Server error occurred. Please try again later.',
    'validationError': 'Please check your input and try again.',
    'unknownError': 'An unexpected error occurred. Please try again.',
  };
});

/// Provider for checking if required dependencies are initialized
final dependenciesInitializedProvider = Provider<bool>((ref) {
  try {
    // Check if all critical dependencies are available
    ref.read(scannerRepositoryProvider);
    ref.read(saveScanUseCaseProvider);
    ref.read(getScanHistoryUseCaseProvider);
    return true;
  } catch (e) {
    return false;
  }
});

/// Helper provider for getting localized error messages
final errorMessageProvider = Provider.family<String, String>((ref, errorKey) {
  final config = ref.watch(errorHandlingConfigProvider);
  return config[errorKey] ?? config['unknownError']!;
});