package com.pixelized.desktop.lwa

import androidx.lifecycle.ViewModel
import com.pixelized.desktop.lwa.repository.alteration.AlterationRepository
import com.pixelized.desktop.lwa.repository.campaign.CampaignRepository
import com.pixelized.desktop.lwa.repository.characterSheet.CharacterSheetRepository
import com.pixelized.desktop.lwa.repository.network.NetworkRepository
import com.pixelized.desktop.lwa.repository.settings.SettingsRepository
import com.pixelized.desktop.lwa.repository.tag.TagRepository
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onEach

class DataSyncViewModel(
    private val characterRepository: CharacterSheetRepository,
    private val alterationRepository: AlterationRepository,
    private val campaignRepository: CampaignRepository,
    private val tagRepository: TagRepository,
    private val settingsRepository: SettingsRepository,
    private val networkRepository: NetworkRepository,
) : ViewModel() {

    fun autoConnect() {
        val settings = settingsRepository.settings()

        if (settings.playerName.isEmpty()) return

        networkRepository.connect(
            host = settings.network.host,
            port = settings.network.port,
        )
    }

    @OptIn(ExperimentalCoroutinesApi::class)
    suspend fun synchronise() = coroutineScope {

        networkRepository.status
            .filter { status -> status == NetworkRepository.Status.CONNECTED }
            .onEach {
                tagRepository.updateAlterationTags()
                alterationRepository.updateAlterations()
                tagRepository.updateCharacterTags()
                characterRepository.updateCharacterPreviews()
                campaignRepository.updateCampaign()
            }
            .launchIn(this)

        networkRepository.status
            .filter { status -> status == NetworkRepository.Status.CONNECTED }
            .flatMapLatest { campaignRepository.campaignFlow.map { it.instances } }
            .distinctUntilChanged()
            .onEach { instances ->
                instances.forEach { characterSheetId ->
                    characterRepository.updateCharacterSheet(
                        characterSheetId = characterSheetId,
                    )
                }
            }
            .launchIn(this)
    }
}