package com.aiosman.ravenow.ui.index.tabs.search

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.paging.Pager
import androidx.paging.PagingConfig
import androidx.paging.PagingData
import androidx.paging.cachedIn
import androidx.paging.map
import com.aiosman.ravenow.data.MomentService
import com.aiosman.ravenow.data.UserServiceImpl
import com.aiosman.ravenow.entity.AccountPagingSource
import com.aiosman.ravenow.entity.AccountProfileEntity
import com.aiosman.ravenow.entity.MomentEntity
import com.aiosman.ravenow.entity.MomentPagingSource
import com.aiosman.ravenow.entity.MomentRemoteDataSource
import com.aiosman.ravenow.entity.MomentServiceImpl
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch

object SearchViewModel : ViewModel() {
    var searchText by mutableStateOf("")
    private val momentService: MomentService = MomentServiceImpl()
    private val _momentsFlow = MutableStateFlow<PagingData<MomentEntity>>(PagingData.empty())
    val momentsFlow = _momentsFlow.asStateFlow()

    private val userService = UserServiceImpl()
    private val _usersFlow = MutableStateFlow<PagingData<AccountProfileEntity>>(PagingData.empty())
    val usersFlow = _usersFlow.asStateFlow()
    var showResult by mutableStateOf(false)
    var requestFocus by mutableStateOf(false)
    fun search() {
        if (searchText.isEmpty()) {
            return
        }
        viewModelScope.launch {
            Pager(
                config = PagingConfig(pageSize = 5, enablePlaceholders = false),
                pagingSourceFactory = {
                    MomentPagingSource(
                        MomentRemoteDataSource(momentService),
                        contentSearch = searchText
                    )
                }
            ).flow.cachedIn(viewModelScope).collectLatest {
                _momentsFlow.value = it
            }
        }
        viewModelScope.launch {
            Pager(
                config = PagingConfig(pageSize = 5, enablePlaceholders = false),
                pagingSourceFactory = {
                    AccountPagingSource(
                        userService,
                        nickname = searchText
                    )
                }
            ).flow.cachedIn(viewModelScope).collectLatest {
                _usersFlow.value = it
            }
        }
        showResult = true
    }

    suspend fun followUser(id:Int){
        userService.followUser(id.toString())
        val currentPagingData = _usersFlow.value
        val updatedPagingData = currentPagingData.map { userItem ->
            if (userItem.id == id) {
                userItem.copy(isFollowing = true, followerCount = userItem.followerCount + 1)
            } else {
                userItem
            }
        }
       _usersFlow.value = updatedPagingData
    }

    suspend fun unfollowUser(id:Int){
        userService.unFollowUser(id.toString())
        val currentPagingData = _usersFlow.value
        val updatedPagingData = currentPagingData.map { userItem ->
            if (userItem.id == id) {
                userItem.copy(isFollowing = false, followerCount = userItem.followerCount - 1)
            } else {
                userItem
            }
        }
       _usersFlow.value = updatedPagingData
    }

    fun ResetModel(){
        _momentsFlow.value = PagingData.empty()
        _usersFlow.value = PagingData.empty()
        showResult = false
    }

    fun updateMomentFollowStatus(authorId:Int,isFollow:Boolean) {
        val currentPagingData = _momentsFlow.value
        val updatedPagingData = currentPagingData.map { momentItem ->
            if (momentItem.authorId == authorId) {
                momentItem.copy(followStatus = isFollow)
            } else {
                momentItem
            }
        }
        _momentsFlow.value = updatedPagingData
    }
    fun momentFollowAction(moment: MomentEntity) {
        viewModelScope.launch {
            try {
                if (moment.followStatus) {
                    userService.unFollowUser(moment.authorId.toString())
                } else {
                    userService.followUser(moment.authorId.toString())
                }
                updateMomentFollowStatus(moment.authorId, !moment.followStatus)
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }
}