private suspend fun fetchFilter(filterId: Int) {
        counter += 1
        _progress.emit(counter)

        when (val r = filtersRepository.getUserFilter(filterId)) {
            is Left -> _errors.emit(r.value)
            is Right -> with(r.value.data) {
                isFilterChanged = true
                _isCallEnabled.emit(canCall)
                groupIds?.let { _listGroupIds.emit(it) }
                eventIds?.let { _listEventIds.emit(it) }
                _type.emit(type)
                filterName?.let { _filterName.emit(it) }
                onSetFilterData(period)
                doUpdateFiltersTable(this)
                getFilterInfo(filterId)
            }
        }

        counter -= 1
        _progress.emit(counter)
    }

    private suspend fun onSetFilterData(filterData: FilterModelData?) {
        _filterRule.emit(filterData?.let {
            when {
                it.daily != null -> {
                    _fromTime.emit(it.daily?.fromTime ?: "00:00")
                    _toTime.emit(it.daily?.toTime ?: "23:59")
                    FilterRule.DAILY
                }
                !it.table.isNullOrEmpty() && (it.table as List).size > 0 -> {
                    it.table?.also { t -> _tables.emit(t) }
                    FilterRule.SCHEDULE
                }
                else -> FilterRule.ALWAYS
            }
        } ?: FilterRule.ALWAYS)
    }

    private suspend fun doUpdateFiltersTable(filter: FilterModel) {
        when (val r = dbRepository.insertFilter(
            Filters(
                filterId = filter.id,
                userId = filter.userId,
                type = filter.type,
                filterName = filter.filterName,
                data = filter.period,
                isCanCall = filter.canCall,
                photoUri = null,
                eventIds = filter.eventIds,
                groupIds = filter.groupIds,
                group_name = filter.groupIds?.let {
                    it.first().id?.let { id -> GroupsName.value(id)?.groupName }
                } ?: NO_GROUP
            )
        )) {
            is Left -> _errors.emit(r.value)
            is Right -> Unit
        }
    }

    private suspend fun getFilterInfo(filterId: Int) {
        when (val r = filtersRepository.getUserFilter(filterId)) {
            is Left -> _errors.emit(r.value)
            is Right -> doUpdateFilterDb(listOf(r.value.data))
        }
    }

    /**
     * Update DB with filter info
     */
    private suspend fun doUpdateFilterDb(filters: List<FilterModel>) {
        when (val r = dbRepository.updateFilters(
            filters.map {
                Filters(
                    filterId = it.id,
                    userId = it.userId,
                    type = it.type,
                    filterName = it.filterName,
                    data = it.period,
                    isCanCall = it.canCall,
                    photoUri = null,
                    eventIds = it.eventIds,
                    groupIds = it.groupIds,
                    group_name = groupName
                )
            }
        )) {
            is Left -> _errors.emit(r.value)
            is Right -> Unit
        }
    }