minhthu/lib/features/scanner/data/datasources/scanner_local_datasource.dart

import 'package:hive_ce/hive.dart';
import '../../../../core/errors/exceptions.dart';
import '../models/scan_item.dart';

/// Abstract local data source for scanner operations
abstract class ScannerLocalDataSource {
  /// Save scan to local storage
  Future<void> saveScan(ScanItem scan);

  /// Get all scans from local storage
  Future<List<ScanItem>> getAllScans();

  /// Get scan by barcode from local storage
  Future<ScanItem?> getScanByBarcode(String barcode);

  /// Update scan in local storage
  Future<void> updateScan(ScanItem scan);

  /// Delete scan from local storage
  Future<void> deleteScan(String barcode);

  /// Clear all scans from local storage
  Future<void> clearAllScans();
}

/// Implementation of ScannerLocalDataSource using Hive
class ScannerLocalDataSourceImpl implements ScannerLocalDataSource {
  static const String _boxName = 'scans';
  Box<ScanItem>? _box;

  /// Initialize Hive box
  Future<Box<ScanItem>> _getBox() async {
    if (_box == null || !_box!.isOpen) {
      try {
        _box = await Hive.openBox<ScanItem>(_boxName);
      } catch (e) {
        throw CacheException('Failed to open Hive box: ${e.toString()}');
      }
    }
    return _box!;
  }

  @override
  Future<void> saveScan(ScanItem scan) async {
    try {
      final box = await _getBox();

      // Use barcode as key to avoid duplicates
      await box.put(scan.barcode, scan);

      // Optional: Log the save operation
      // print('Scan saved locally: ${scan.barcode}');

    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to save scan locally: ${e.toString()}');
    }
  }

  @override
  Future<List<ScanItem>> getAllScans() async {
    try {
      final box = await _getBox();

      // Get all values from the box
      final scans = box.values.toList();

      // Sort by timestamp (most recent first)
      scans.sort((a, b) => b.timestamp.compareTo(a.timestamp));

      return scans;

    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to get scans from local storage: ${e.toString()}');
    }
  }

  @override
  Future<ScanItem?> getScanByBarcode(String barcode) async {
    try {
      if (barcode.trim().isEmpty) {
        throw const ValidationException('Barcode cannot be empty');
      }

      final box = await _getBox();

      // Get scan by barcode key
      return box.get(barcode);

    } on ValidationException {
      rethrow;
    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to get scan by barcode: ${e.toString()}');
    }
  }

  @override
  Future<void> updateScan(ScanItem scan) async {
    try {
      final box = await _getBox();

      // Check if scan exists
      if (!box.containsKey(scan.barcode)) {
        throw CacheException('Scan with barcode ${scan.barcode} not found');
      }

      // Update the scan
      await box.put(scan.barcode, scan);

      // Optional: Log the update operation
      // print('Scan updated locally: ${scan.barcode}');

    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to update scan locally: ${e.toString()}');
    }
  }

  @override
  Future<void> deleteScan(String barcode) async {
    try {
      if (barcode.trim().isEmpty) {
        throw const ValidationException('Barcode cannot be empty');
      }

      final box = await _getBox();

      // Check if scan exists
      if (!box.containsKey(barcode)) {
        throw CacheException('Scan with barcode $barcode not found');
      }

      // Delete the scan
      await box.delete(barcode);

      // Optional: Log the delete operation
      // print('Scan deleted locally: $barcode');

    } on ValidationException {
      rethrow;
    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to delete scan locally: ${e.toString()}');
    }
  }

  @override
  Future<void> clearAllScans() async {
    try {
      final box = await _getBox();

      // Clear all scans
      await box.clear();

      // Optional: Log the clear operation
      // print('All scans cleared from local storage');

    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to clear all scans: ${e.toString()}');
    }
  }

  /// Get scans count (utility method)
  Future<int> getScansCount() async {
    try {
      final box = await _getBox();
      return box.length;
    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to get scans count: ${e.toString()}');
    }
  }

  /// Check if scan exists (utility method)
  Future<bool> scanExists(String barcode) async {
    try {
      if (barcode.trim().isEmpty) {
        return false;
      }

      final box = await _getBox();
      return box.containsKey(barcode);
    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to check if scan exists: ${e.toString()}');
    }
  }

  /// Get scans within date range (utility method)
  Future<List<ScanItem>> getScansByDateRange({
    required DateTime startDate,
    required DateTime endDate,
  }) async {
    try {
      final allScans = await getAllScans();

      // Filter by date range
      final filteredScans = allScans.where((scan) {
        return scan.timestamp.isAfter(startDate) &&
               scan.timestamp.isBefore(endDate);
      }).toList();

      return filteredScans;
    } on CacheException {
      rethrow;
    } catch (e) {
      throw CacheException('Failed to get scans by date range: ${e.toString()}');
    }
  }

  /// Close the Hive box (call this when app is closing)
  Future<void> dispose() async {
    if (_box != null && _box!.isOpen) {
      await _box!.close();
      _box = null;
    }
  }
}