// Events
abstract class ReconciliationEvent extends Equatable {}

class LoadReconciliation extends ReconciliationEvent {}
class CreateReconciliation extends ReconciliationEvent {}
class UpdateReconciliation extends ReconciliationEvent {}
class DeleteReconciliation extends ReconciliationEvent {}

// States
abstract class ReconciliationState extends Equatable {}

class ReconciliationInitial extends ReconciliationState {}
class ReconciliationLoading extends ReconciliationState {}
class ReconciliationLoaded extends ReconciliationState {}
class ReconciliationError extends ReconciliationState {}

// BLoC
class ReconciliationBloc extends Bloc<ReconciliationEvent, ReconciliationState> {
  final ReconciliationRepository _repository;
  
  ReconciliationBloc({required ReconciliationRepository repository})
      : _repository = repository,
        super(ReconciliationInitial()) {
    on<LoadReconciliation>(_onLoad);
    on<CreateReconciliation>(_onCreate);
    on<UpdateReconciliation>(_onUpdate);
    on<DeleteReconciliation>(_onDelete);
  }
  
  Future<void> _onLoad(
    LoadReconciliation event,
    Emitter<ReconciliationState> emit,
  ) async {
    emit(ReconciliationLoading());
    
    final result = await _repository.getReconciliations();
    
    result.fold(
      (failure) => emit(ReconciliationError(failure.message)),
      (data) => emit(ReconciliationLoaded(data)),
    );
  }
}

abstract class ReconciliationRepository {
  Future<Either<Failure, List<Reconciliation>>> getReconciliations();
  Future<Either<Failure, Reconciliation>> getReconciliationById(String id);
  Future<Either<Failure, Reconciliation>> createReconciliation(Reconciliation data);
  Future<Either<Failure, Reconciliation>> updateReconciliation(String id, Reconciliation data);
  Future<Either<Failure, void>> deleteReconciliation(String id);
}

class ReconciliationRepositoryImpl implements ReconciliationRepository {
  final ReconciliationApi _api;
  final ReconciliationLocalRepository _localRepo;
  
  @override
  Future<Either<Failure, List<Reconciliation>>> getReconciliations() async {
    try {
      // Try local first (offline-first)
      final local = await _localRepo.getReconciliations();
      
      // Sync with API in background
      final result = await _api.getReconciliations();
      result.fold(
        (failure) => null,
        (data) => _localRepo.saveReconciliations(data),
      );
      
      return Right(local.isNotEmpty ? local : result.getOrElse(() => []));
    } catch (e) {
      return Left(UnexpectedFailure(e.toString()));
    }
  }
}

GET /api/v1/reconciliations/*
Authorization: Bearer {access_token}

{
  "success": true,
  "data": [
    {
      "id": "123",
      "name": "Example",
      "created_at": "2024-10-14T10:00:00Z"
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 20,
    "total": 100
  }
}

@collection
class ReconciliationLocal {
  Id id = Isar.autoIncrement;
  
  @Index()
  String? reconciliationId;
  
  String? name;
  DateTime? createdAt;
  DateTime? updatedAt;
  DateTime? syncedAt;
  
  bool? isSynced;
  bool? isDeleted;
}

// Get all
final items = await isar.reconciliationLocals.where().findAll();

// Get by ID
final item = await isar.reconciliationLocals
    .filter()
    .reconciliationIdEqualTo(id)
    .findFirst();

// Search
final results = await isar.reconciliationLocals
    .filter()
    .nameContains(query, caseSensitive: false)
    .findAll();

// Get unsynced
final unsynced = await isar.reconciliationLocals
    .filter()
    .isSyncedEqualTo(false)
    .findAll();

class ReconciliationPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocProvider(
      create: (context) => getIt<ReconciliationBloc>()..add(LoadReconciliation()),
      child: Scaffold(
        appBar: AppBar(title: Text('Cash Reconciliation')),
        body: BlocBuilder<ReconciliationBloc, ReconciliationState>(
          builder: (context, state) {
            if (state is ReconciliationLoading) {
              return Center(child: CircularProgressIndicator());
            }
            
            if (state is ReconciliationError) {
              return ErrorWidget(message: state.message);
            }
            
            if (state is ReconciliationLoaded) {
              return ReconciliationListView(items: state.items);
            }
            
            return SizedBox.shrink();
          },
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: () => _navigateToCreate(context),
          child: Icon(Icons.add),
        ),
      ),
    );
  }
}

void main() {
  group('ReconciliationBloc', () {
    late ReconciliationBloc bloc;
    late MockReconciliationRepository mockRepository;

    setUp(() {
      mockRepository = MockReconciliationRepository();
      bloc = ReconciliationBloc(repository: mockRepository);
    });

    tearDown(() {
      bloc.close();
    });

    test('initial state is ReconciliationInitial', () {
      expect(bloc.state, equals(ReconciliationInitial()));
    });

    blocTest<ReconciliationBloc, ReconciliationState>(
      'emits [Loading, Loaded] when Load succeeds',
      build: () {
        when(() => mockRepository.getReconciliations()).thenAnswer(
          (_) async => Right([Reconciliation(id: '1', name: 'Test')]),
        );
        return bloc;
      },
      act: (bloc) => bloc.add(LoadReconciliation()),
      expect: () => [
        ReconciliationLoading(),
        isA<ReconciliationLoaded>(),
      ],
    );
  });
}