public func sync(with remoteState: CallState) {
        guard
            !self.isFinished &&
            remoteState.revision >= self.revision &&
            (remoteState.localStreamEnabled != nil || remoteState.remoteStreamEnabled != nil)
        else {
            return
        }

        self.revision = remoteState.revision

        var lastRemote = self.remote ?? State(local: false, remote: false)
        if let localEnabled = remoteState.localStreamEnabled {
            lastRemote.local = localEnabled
            self.sync(remote: localEnabled, direction: .local)
        }
        if let remoteEnabled = remoteState.remoteStreamEnabled {
            lastRemote.remote = remoteEnabled
            self.sync(remote: remoteEnabled, direction: .remote)
        }
        self.remote = lastRemote

        self.updateState()
        self.updateStatus(localUpdate: false)
    }

    private func sync(remote state: Bool, direction: Direction) {
        self.transition[direction.opposite] = state && !self.synced[direction.opposite] && !self.pending[direction.opposite]
        self.synced[direction.opposite] = state && (self.synced[direction.opposite] || self.pending[direction.opposite])
        self.pending[direction.opposite] = false
    }

    public func set(localStreamEnabled: Bool?, remoteStreamEnabled: Bool?, increaseRevision: Bool) {
        guard !self.isFinished && (localStreamEnabled != nil || remoteStreamEnabled != nil) else { return }
        guard self.statusSubject.value == nil ||
            (self.stateSubject.value.localStreamEnabled != localStreamEnabled ||
            self.stateSubject.value.remoteStreamEnabled != remoteStreamEnabled)
        else {
            return
        }

        if increaseRevision {
            self.revision += 1
        }

        if let localEnabled = localStreamEnabled {
            self.set(local: localEnabled, direction: .local)
        }
        if let remoteEnabled = remoteStreamEnabled {
            self.set(local: remoteEnabled, direction: .remote)
        }

        self.updateState()
        self.updateStatus(localUpdate: true)
    }

    private func set(local state: Bool, direction: Direction) {
        self.synced[direction] = state && self.remote?[direction.opposite] == true
        self.pending[direction] = state && !self.synced[direction]
        self.transition[direction] = false
    }