/* Copyright 2018 Conny Duck
 *
 * This file is a part of Tusky.
 *
 * This program is free software; you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation; either version 3 of the
 * License, or (at your option) any later version.
 *
 * Tusky is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with Tusky; if not,
 * see <http://www.gnu.org/licenses>. */

package com.keylesspalace.tusky.viewmodel

import android.app.Application
import android.net.Uri
import androidx.core.net.toUri
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import at.connyduck.calladapter.networkresult.fold
import com.keylesspalace.tusky.appstore.EventHub
import com.keylesspalace.tusky.appstore.ProfileEditedEvent
import com.keylesspalace.tusky.components.instanceinfo.InstanceInfo
import com.keylesspalace.tusky.components.instanceinfo.InstanceInfoRepository
import com.keylesspalace.tusky.entity.Account
import com.keylesspalace.tusky.entity.StringField
import com.keylesspalace.tusky.network.MastodonApi
import com.keylesspalace.tusky.util.Error
import com.keylesspalace.tusky.util.Loading
import com.keylesspalace.tusky.util.Resource
import com.keylesspalace.tusky.util.Success
import com.keylesspalace.tusky.util.getServerErrorMessage
import com.keylesspalace.tusky.util.randomAlphanumericString
import java.io.File
import javax.inject.Inject
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.asFlow
import kotlinx.coroutines.flow.shareIn
import kotlinx.coroutines.launch
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.MultipartBody
import okhttp3.RequestBody.Companion.asRequestBody
import okhttp3.RequestBody.Companion.toRequestBody

private const val HEADER_FILE_NAME = "header.png"
private const val AVATAR_FILE_NAME = "avatar.png"

internal data class ProfileDataInUi(
    val displayName: String,
    val note: String,
    val locked: Boolean,
    val fields: List<StringField>
)

class EditProfileViewModel @Inject constructor(
    private val mastodonApi: MastodonApi,
    private val eventHub: EventHub,
    private val application: Application,
    private val instanceInfoRepo: InstanceInfoRepository
) : ViewModel() {

    val profileData = MutableLiveData<Resource<Account>>()
    val avatarData = MutableLiveData<Uri>()
    val headerData = MutableLiveData<Uri>()
    val saveData = MutableLiveData<Resource<Nothing>>()

    val instanceData: Flow<InstanceInfo> = instanceInfoRepo::getUpdatedInstanceInfoOrFallback.asFlow()
        .shareIn(viewModelScope, SharingStarted.Eagerly, replay = 1)

    val isChanged = MutableStateFlow(false)

    private var apiProfileAccount: Account? = null

    fun obtainProfile() = viewModelScope.launch {
        if (profileData.value == null || profileData.value is Error) {
            profileData.postValue(Loading())

            mastodonApi.accountVerifyCredentials().fold(
                { profile ->
                    apiProfileAccount = profile
                    profileData.postValue(Success(profile))
                },
                {
                    profileData.postValue(Error())
                }
            )
        }
    }

    fun getAvatarUri() = getCacheFileForName(AVATAR_FILE_NAME).toUri()

    fun getHeaderUri() = getCacheFileForName(HEADER_FILE_NAME).toUri()

    fun newAvatarPicked() {
        avatarData.value = getAvatarUri()
    }

    fun newHeaderPicked() {
        headerData.value = getHeaderUri()
    }

    internal fun dataChanged(newProfileData: ProfileDataInUi) {
        isChanged.value = getProfileDiff(apiProfileAccount, newProfileData).hasChanges()
    }

    internal fun save(newProfileData: ProfileDataInUi) {
        if (saveData.value is Loading || profileData.value !is Success) {
            return
        }

        saveData.value = Loading()

        val diff = getProfileDiff(apiProfileAccount, newProfileData)
        if (!diff.hasChanges()) {
            // if nothing has changed, there is no need to make an api call
            saveData.value = Success()
            return
        }

        viewModelScope.launch {
            var avatarFileBody: MultipartBody.Part? = null
            diff.avatarFile?.let {
                avatarFileBody = MultipartBody.Part.createFormData(
                    "avatar",
                    randomAlphanumericString(12),
                    it.asRequestBody("image/png".toMediaTypeOrNull())
                )
            }

            var headerFileBody: MultipartBody.Part? = null
            diff.headerFile?.let {
                headerFileBody = MultipartBody.Part.createFormData(
                    "header",
                    randomAlphanumericString(12),
                    it.asRequestBody("image/png".toMediaTypeOrNull())
                )
            }

            mastodonApi.accountUpdateCredentials(
                diff.displayName?.toRequestBody(MultipartBody.FORM),
                diff.note?.toRequestBody(MultipartBody.FORM),
                diff.locked?.toString()?.toRequestBody(MultipartBody.FORM),
                avatarFileBody,
                headerFileBody,
                diff.field1?.first?.toRequestBody(MultipartBody.FORM),
                diff.field1?.second?.toRequestBody(MultipartBody.FORM),
                diff.field2?.first?.toRequestBody(MultipartBody.FORM),
                diff.field2?.second?.toRequestBody(MultipartBody.FORM),
                diff.field3?.first?.toRequestBody(MultipartBody.FORM),
                diff.field3?.second?.toRequestBody(MultipartBody.FORM),
                diff.field4?.first?.toRequestBody(MultipartBody.FORM),
                diff.field4?.second?.toRequestBody(MultipartBody.FORM)
            ).fold(
                { newAccountData ->
                    saveData.postValue(Success())
                    eventHub.dispatch(ProfileEditedEvent(newAccountData))
                },
                { throwable ->
                    saveData.postValue(Error(errorMessage = throwable.getServerErrorMessage()))
                }
            )
        }
    }

    // cache activity state for rotation change
    internal fun updateProfile(newProfileData: ProfileDataInUi) {
        if (profileData.value is Success) {
            val newProfileSource = profileData.value?.data?.source?.copy(
                note = newProfileData.note,
                fields = newProfileData.fields
            )
            val newProfile = profileData.value?.data?.copy(
                displayName = newProfileData.displayName,
                locked = newProfileData.locked,
                source = newProfileSource
            )

            profileData.value = Success(newProfile)
        }
    }

    private fun getProfileDiff(
        oldProfileAccount: Account?,
        newProfileData: ProfileDataInUi
    ): DiffProfileData {
        val displayName = if (oldProfileAccount?.displayName == newProfileData.displayName) {
            null
        } else {
            newProfileData.displayName
        }

        val note = if (oldProfileAccount?.source?.note == newProfileData.note) {
            null
        } else {
            newProfileData.note
        }

        val locked = if (oldProfileAccount?.locked == newProfileData.locked) {
            null
        } else {
            newProfileData.locked
        }

        val avatarFile = if (avatarData.value != null) {
            getCacheFileForName(AVATAR_FILE_NAME)
        } else {
            null
        }

        val headerFile = if (headerData.value != null) {
            getCacheFileForName(HEADER_FILE_NAME)
        } else {
            null
        }

        // when one field changed, all have to be sent or they unchanged ones would get overridden
        val allFieldsUnchanged = oldProfileAccount?.source?.fields == newProfileData.fields
        val field1 = calculateFieldToUpdate(newProfileData.fields.getOrNull(0), allFieldsUnchanged)
        val field2 = calculateFieldToUpdate(newProfileData.fields.getOrNull(1), allFieldsUnchanged)
        val field3 = calculateFieldToUpdate(newProfileData.fields.getOrNull(2), allFieldsUnchanged)
        val field4 = calculateFieldToUpdate(newProfileData.fields.getOrNull(3), allFieldsUnchanged)

        return DiffProfileData(
            displayName, note, locked, field1, field2, field3, field4, headerFile, avatarFile
        )
    }

    private fun calculateFieldToUpdate(
        newField: StringField?,
        fieldsUnchanged: Boolean
    ): Pair<String, String>? {
        if (fieldsUnchanged || newField == null) {
            return null
        }
        return Pair(
            newField.name,
            newField.value
        )
    }

    private fun getCacheFileForName(filename: String): File {
        return File(application.cacheDir, filename)
    }

    private data class DiffProfileData(
        val displayName: String?,
        val note: String?,
        val locked: Boolean?,
        val field1: Pair<String, String>?,
        val field2: Pair<String, String>?,
        val field3: Pair<String, String>?,
        val field4: Pair<String, String>?,
        val headerFile: File?,
        val avatarFile: File?
    ) {
        fun hasChanges() = displayName != null || note != null || locked != null ||
            avatarFile != null || headerFile != null || field1 != null || field2 != null ||
            field3 != null || field4 != null
    }
}