extension Reactive where Base: UITableView {
    func modelLongPressed<T>(_ modelType: T.Type) -> ControlEvent<(UITableViewCell, T)> {
        let longPressGesture = UILongPressGestureRecognizer(target: nil, action: nil)
        
        base.addGestureRecognizer(longPressGesture)
        let source = longPressGesture.rx.event
            .filter { $0.state == .began }
            .map { base.indexPathForRow(at: $0.location(in: base)) }
            .flatMap { [weak tableView = base as UITableView] indexPath -> Observable<(UITableViewCell, T)> in
                guard let tableView = tableView,
                      let indexPath = indexPath,
                      let cell = tableView.cellForRow(at: indexPath) else { return Observable.empty() }
                return Observable.zip(
                    Observable.just(cell),
                    Observable.just(try tableView.rx.model(at: indexPath))
                )
            }
        return ControlEvent(events: source)
    }
}

 let longPressGesture: UILongPressGestureRecognizer = {
            let gesture = UILongPressGestureRecognizer(target: nil, action: nil)
            gesture.minimumPressDuration = 0.5
            return gesture
        }()

protocol DatabaseManagerProtocol {
    var todoListBehaviorRelay: BehaviorRelay<[Todo]> { get }
    var historyBehaviorRelay: BehaviorRelay<[History]> { get }

    func create(todoData: Todo)
    func update(selectedTodo: Todo)
    func delete(todoID: UUID)
    func isConnected() -> Observable<Bool>
    func isHistoryEmpty() -> Observable<Bool>
    func deleteHistory()
}

final class DatabaseManager: DatabaseManagerProtocol {
        // 실제 구현이 이루어지는 곳
    let todoListBehaviorRelay = BehaviorRelay<[Todo]>(value: [])
    let historyBehaviorRelay = BehaviorRelay<[History]>(value: [])

    private let realm = RealmDatabase()
    private let firebase = FirebaseDatabase()
}

// RealDatabase.swift
enum CRUDType {
    case create(at: Todo)
    case update(at: Todo)
    case delete(at: UUID)
    case read(at: [Todo])
}

let dataBehaviorRelay = BehaviorRelay<CRUDType>(value: .read(at: []))

func create(todoData: Todo) {
    try? self.realm?.write { [weak self] in
        self?.realm?.add(todoData.todoDTO())
    }
    self.dataBehaviorRelay.accept(.create(at: todoData))
}

// DatabaseManager.swift
private func bind() {
    self.realm.dataBehaviorRelay.subscribe(onNext: { CRUDType in
        switch CRUDType {
        case .create(at: let todoData):
            self.firebase.create(todoData: todoData)
        case .update(at: let selectedTodoData):
            self.firebase.update(selectedTodo: selectedTodoData)
        case .delete(at: let selectedTodoData):
            self.firebase.delete(todoID: selectedTodoData)
        case .read(at: let todoDataList):
            self.firebase.sync(todoData: todoDataList)
            self.todoListBehaviorRelay.accept(todoDataList)
        }
    })
    .disposed(by: self.disposeBag)
}

// NotificationManager.swift
func setNotification(todoData: Todo) {
    // 생략
    
    var todoDateComponent = Calendar.current.dateComponents([.year, .month, .day], from: todoData.date)
    todoDateComponent.hour = 9

    let trigger = UNCalendarNotificationTrigger(dateMatching: todoDateComponent, repeats: false)
    let request = UNNotificationRequest(
        identifier: todoData.identifier.uuidString,
        content: content,
        trigger: trigger
    )
    self.notificationCenter.add(request)
}

func deleteNotification(todoIdentifier: String) {
    self.notificationCenter.removePendingNotificationRequests(withIdentifiers: [todoIdentifier])
}

func updateNotification(todoData: Todo) {
    guard todoData.todoListItemStatus != .done else {
        return deleteNotification(todoIdentifier: todoData.identifier.uuidString)
    }
    self.setNotification(todoData: todoData)
}

final class UndoRedoManager {
    let undoRelay = PublishRelay<Void>()
    let redoRelay = PublishRelay<Void>()

    private var undoDataStack: [History] = []
    private var redoDataStack: [History] = []
}

self.undoRelay
    .subscribe(onNext: { [weak self] _ in
        guard let lastHistory = self?.undoDataStack.removeLast() else { return }
        self?.undoRedoActionAble.undoTapEvent(history: lastHistory)
        self?.redoDataStack.append(lastHistory)
    })
    .disposed(by: self.disposeBag)

self.redoRelay
    .subscribe(onNext: { [weak self] _ in
        guard let lastHistory = self?.redoDataStack.removeLast() else { return }
        self?.undoRedoActionAble.redoTapEvent(history: lastHistory)
    })
    .disposed(by: self.disposeBag)

func isRedoEmpty() -> Observable<Bool> {
    return Observable.create { observer in
        let _ = Observable.of(self.undoRelay, self.redoRelay)
            .merge()
            .subscribe(onNext: { [weak self] _ in
                if self?.redoDataStack.count == 0 {
                    observer.onNext(false)
                } else {
                    observer.onNext(true)
                }
            })
        return Disposables.create()
    }
}

// TodoListViewModel.swift
self.isRedoEmpty = self.undoRedoManager.isRedoEmpty()
    .asDriver(onErrorJustReturn: false)

// TodoListViewController.swift
self.viewModel.isRedoEmpty
    .drive(onNext: { [weak self] isRedo in
        self?.isRedoButtonActive(isRedoEmpty: isRedo)
    })
    .disposed(by: self.disposeBag)