ProductEditNutritionFactsFragment.kt

/*
 * Copyright 2016-2020 Open Food Facts
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package openfoodfacts.github.scrachx.openfood.features.product.edit.nutrition

import android.content.Intent
import android.content.SharedPreferences
import android.os.Bundle
import android.text.Editable
import android.text.Html
import android.text.InputType
import android.text.TextWatcher
import android.text.method.NumberKeyListener
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
import android.widget.*
import android.widget.AdapterView.OnItemSelectedListener
import androidx.core.net.toFile
import androidx.core.widget.doAfterTextChanged
import androidx.fragment.app.viewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import com.afollestad.materialdialogs.MaterialDialog
import com.google.android.material.textfield.TextInputLayout
import com.squareup.picasso.Callback
import com.squareup.picasso.Picasso
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.rx2.awaitSingleOrNull
import kotlinx.coroutines.withContext
import openfoodfacts.github.scrachx.openfood.R
import openfoodfacts.github.scrachx.openfood.analytics.AnalyticsView
import openfoodfacts.github.scrachx.openfood.analytics.MatomoAnalytics
import openfoodfacts.github.scrachx.openfood.analytics.SentryAnalytics
import openfoodfacts.github.scrachx.openfood.databinding.FragmentAddProductNutritionFactsBinding
import openfoodfacts.github.scrachx.openfood.features.product.edit.*
import openfoodfacts.github.scrachx.openfood.features.product.edit.ProductEditActivity.Companion.KEY_EDIT_OFFLINE_PRODUCT
import openfoodfacts.github.scrachx.openfood.features.shared.views.CustomValidatingEditTextView
import openfoodfacts.github.scrachx.openfood.images.ProductImage
import openfoodfacts.github.scrachx.openfood.models.*
import openfoodfacts.github.scrachx.openfood.models.Units.UNIT_DV
import openfoodfacts.github.scrachx.openfood.models.Units.UNIT_GRAM
import openfoodfacts.github.scrachx.openfood.models.Units.UNIT_LITER
import openfoodfacts.github.scrachx.openfood.models.Units.UNIT_MICROGRAM
import openfoodfacts.github.scrachx.openfood.models.Units.UNIT_MILLIGRAM
import openfoodfacts.github.scrachx.openfood.models.Units.UNIT_MILLILITRE
import openfoodfacts.github.scrachx.openfood.models.entities.OfflineSavedProduct
import openfoodfacts.github.scrachx.openfood.network.ApiFields
import openfoodfacts.github.scrachx.openfood.network.ApiFields.Defaults.NUTRITION_DATA_PER_100G
import openfoodfacts.github.scrachx.openfood.network.ApiFields.Defaults.NUTRITION_DATA_PER_SERVING
import openfoodfacts.github.scrachx.openfood.network.OpenFoodAPIClient
import openfoodfacts.github.scrachx.openfood.utils.*
import openfoodfacts.github.scrachx.openfood.utils.FileDownloader.download
import openfoodfacts.github.scrachx.openfood.utils.UnitUtils.UNIT_IU
import openfoodfacts.github.scrachx.openfood.utils.Utils.getRoundNumber
import java.io.File
import java.text.Collator
import java.util.*
import javax.inject.Inject

/**
 * @see R.layout.fragment_add_product_nutrition_facts
 */
@AndroidEntryPoint
class ProductEditNutritionFactsFragment : ProductEditFragment() {
    private var _binding: FragmentAddProductNutritionFactsBinding? = null
    private val binding get() = _binding!!

    val viewModel: ProductEditNutritionViewModel by viewModels()

    @Inject
    lateinit var picasso: Picasso

    @Inject
    lateinit var client: OpenFoodAPIClient

    @Inject
    lateinit var matomoAnalytics: MatomoAnalytics

    @Inject
    lateinit var sentryAnalytics: SentryAnalytics

    @Inject
    lateinit var sharedPreferences: SharedPreferences

    @Inject
    lateinit var localeManager: LocaleManager

    private val keyListener = object : NumberKeyListener() {
        override fun getInputType() = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD

        override fun getAcceptedChars() = charArrayOf('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ',', '.')
    }

    private val photoReceiverHandler: PhotoReceiverHandler by lazy {
        PhotoReceiverHandler(sharedPreferences) {
            val resultUri = it.toURI()
            imagePath = resultUri.path
            photoFile = it
            val image = ProductImage(productCode!!, ProductImageField.NUTRITION, it, localeManager.getLanguage()).apply {
                filePath = resultUri.path
            }
            (activity as? ProductEditActivity)?.savePhoto(image, 2)
            hideImageProgress(false, "")
        }
    }
    private var photoFile: File? = null
    private var productCode: String? = null
    private var mOfflineSavedProduct: OfflineSavedProduct? = null
    private var imagePath: String? = null

    //index list stores the index of other nutrients which are used.
    private val usedNutrientsIndexes = mutableSetOf<Int>()
    private var product: Product? = null

    private var lastEditText: EditText? = null
    private var starchEditText: CustomValidatingEditTextView? = null
    private var allEditViews = mutableSetOf<CustomValidatingEditTextView>()

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
        _binding = FragmentAddProductNutritionFactsBinding.inflate(inflater, container, false)
        return binding.root
    }


    private fun Spinner.setOnItemSelectedListener(
        block: (
            parent: AdapterView<*>?,
            view: View?,
            position: Int,
            id: Long
        ) -> Unit
    ) {
        this.onItemSelectedListener = object : OnItemSelectedListener {
            override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) =
                block(parent, view, position, id)

            override fun onNothingSelected(parent: AdapterView<*>?) = Unit // This is not possible
        }
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        binding.viewModel = viewModel
        binding.lifecycleOwner = this

        binding.btnAddImageNutritionFacts.setOnClickListener { addNutritionFactsImage() }
        binding.btnEditImageNutritionFacts.setOnClickListener { newNutritionFactsImage() }
        binding.btnAdd.setOnClickListener { next() }
        binding.for100g100ml.setOnClickListener { checkAllValues() }
        binding.btnAddANutrient.setOnClickListener { displayAddNutrientDialog() }

        binding.salt.doAfterTextChanged { updateSodiumValue() }
        binding.spinnerSaltComp.setOnItemSelectedListener { _, _, _, _ ->
            binding.spinnerSodiumComp.setSelection(binding.spinnerSaltComp.selectedItemPosition)
        }

        binding.sodium.doAfterTextChanged { updateSaltValue() }
        binding.spinnerSodiumComp.setOnItemSelectedListener { _, _, _, _ ->
            binding.spinnerSaltComp.setSelection(binding.spinnerSodiumComp.selectedItemPosition)
        }


        val bundle = arguments
        lastEditText = binding.alcohol

        if (bundle == null) {
            closeScreenWithAlert()
            return
        }

        product = bundle.getSerializable("product") as Product?
        mOfflineSavedProduct = bundle.getSerializable(KEY_EDIT_OFFLINE_PRODUCT) as OfflineSavedProduct?
        val productEdited = bundle.getBoolean(ProductEditActivity.KEY_IS_EDITING)
        if (product != null) {
            productCode = product!!.code
            viewModel.product.value = product
        }
        if (productEdited && product != null) {
            productCode = product!!.code
            binding.btnAdd.setText(R.string.save_edits)
            preFillProductValues()
        } else if (mOfflineSavedProduct != null) {
            productCode = mOfflineSavedProduct!!.barcode
            preFillValuesFromOffline()
        } else {
            binding.radioGroup.jumpDrawablesToCurrentState()
        }
        binding.alcohol.imeOptions = EditorInfo.IME_ACTION_DONE
        binding.energyKcal.requestFocus()
        allEditViews = (view as ViewGroup).getViewsByType(CustomValidatingEditTextView::class.java).toHashSet()
        allEditViews.forEach {
            it.addValidListener()
            it.checkValue()
        }
        (activity as? ProductEditActivity)?.initialValues?.let { values ->
            addAllFieldsToMap(values)
        }
    }

    override fun onResume() {
        super.onResume()
        matomoAnalytics.trackView(AnalyticsView.ProductEditNutritionFacts)
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }

    private fun checkAllValues() = allEditViews.forEach { it.checkValue() }

    override fun allValid() = allEditViews.none { it.isError() }

    private fun requireAddProductActivity() = requireActivity() as ProductEditActivity

    /**
     * Pre fill the fields of the product which are already present on the server.
     */
    private fun preFillProductValues() {
        loadNutritionImage()

        // Set no nutrition data checkbox
        if (product!!.noNutritionData.equals("on", true)) {
            binding.checkboxNoNutritionData.isChecked = true
            binding.nutritionFactsLayout.visibility = View.GONE
        }

        // Set nutrition data per
        product!!.nutritionDataPer
            ?.takeUnless { it.isEmpty() }
            ?.let { updateSelectedDataPer(it) }


        // Set serving size
        product!!.servingSize
            ?.takeUnless { it.isEmpty() }
            // Splits the serving size into value and unit. Example: "15g" into "15" and "g"
            ?.let { updateServingSizeFrom(it) }

        if (view == null) return

        val nutriments = product!!.nutriments
        binding.energyKj.setText(nutriments.getEnergyKjValue(isDataPerServing))
        binding.energyKcal.setText(nutriments.getEnergyKcalValue(isDataPerServing))

        // Fill default nutriments fields
        (view as ViewGroup).getViewsByType(CustomValidatingEditTextView::class.java).forEach { view ->
            var nutrientShortName = view.entryName

            // Workaround for saturated-fat
            if (nutrientShortName == "saturated_fat") nutrientShortName = "saturated-fat"

            // Skip serving size and energy view, we already filled them
            if (view === binding.servingSize || view === binding.energyKcal || view === binding.energyKj) return@forEach

            // Get the value
            val value = if (isDataPer100g) nutriments[nutrientShortName]?.for100g else nutriments[nutrientShortName]?.forServing
            if (value.isNullOrEmpty()) return@forEach

            view.setText(value)
            view.unitSpinner?.setSelection(getSelectedUnitFromShortName(nutriments, nutrientShortName))
            view.modSpinner?.setSelection(getSelectedModifierFromShortName(nutriments, nutrientShortName))
        }

        // Set the values of all the other nutrients if defined and create new row in the tableLayout.
        PARAMS_OTHER_NUTRIENTS.withIndex().forEach { (i, nutrient) ->
            val nutrientShortName = getShortName(nutrient)

            val value = if (isDataPer100g) nutriments[nutrientShortName]?.for100g else nutriments[nutrientShortName]?.forServing
            if (value.isNullOrEmpty()) return@forEach

            val unitIndex = getSelectedUnitFromShortName(nutriments, nutrientShortName)
            val modIndex = getSelectedModifierFromShortName(nutriments, nutrientShortName)

            usedNutrientsIndexes += i

            val nutrientNames = resources.getStringArray(R.array.nutrients_array)
            addNutrientRow(i, nutrientNames[i], true, value, unitIndex, modIndex)
        }
    }

    /**
     * Load the nutrition image uploaded form AddProductActivity
     */
    fun loadNutritionImage() {
        photoFile = null
        val newImageNutritionUrl = product?.getImageNutritionUrl(requireAddProductActivity().getProductLanguageForEdition())
        if (newImageNutritionUrl.isNullOrEmpty()) return

        binding.imageProgress.visibility = View.VISIBLE
        imagePath = newImageNutritionUrl
        loadNutritionImage(imagePath!!)
    }

    private fun getSelectedUnitFromShortName(nutriments: Nutriments, nutrientShortName: String): Int =
        getSelectedUnit(nutrientShortName, nutriments[nutrientShortName]?.unit)

    private fun getSelectedUnit(nutrientShortName: String?, unit: String?) = if (unit != null) {
        if (Nutriments.ENERGY_KCAL == nutrientShortName || Nutriments.ENERGY_KJ == nutrientShortName)
            throw IllegalArgumentException("Nutrient cannot be energy")
        else getPositionInAllUnitArray(unit)
    } else 0

    private fun getSelectedModifierFromShortName(nutriments: Nutriments, nutrientShortName: String): Int =
        getPositionInModifierArray(nutriments[nutrientShortName]?.modifier ?: "")

    private fun updateServingSizeFrom(servingSize: String) {
        val part = servingSize.split(Regex("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)")).toTypedArray()
        binding.servingSize.setText(part[0])
        if (part.size > 1) {
            binding.servingSize.unitSpinner?.setSelection(getPositionInServingUnitArray(part[1].trim { it <= ' ' }))
        }
    }

    /**
     * Pre fill the fields if the product is already present in SavedProductOffline db.
     */
    private fun preFillValuesFromOffline() {
        val productDetails = mOfflineSavedProduct!!.productDetails

        if (productDetails["image_nutrition_facts"] != null) {
            imagePath = productDetails["image_nutrition_facts"]
            val path = "$LOCALE_FILE_SCHEME$imagePath"
            binding.imageProgress.visibility = View.VISIBLE
            loadNutritionImage(path)
        }

        if (productDetails[ApiFields.Keys.NO_NUTRITION_DATA] != null) {
            binding.checkboxNoNutritionData.isChecked = true
            binding.nutritionFactsLayout.visibility = View.GONE
        }

        productDetails[ApiFields.Keys.NUTRITION_DATA_PER]?.let { nutritionDataPer ->
            // can be "100g" or "serving"
            updateSelectedDataPer(nutritionDataPer)
        }
        productDetails[ApiFields.Keys.SERVING_SIZE]?.let {
            // Splits the serving size into value and unit. Example: "15g" into "15" and "g"
            updateServingSizeFrom(it)
        }

        (binding.root as ViewGroup).getViewsByType(CustomValidatingEditTextView::class.java).forEach { view ->
            val nutrientShortName = view.entryName
            if (nutrientShortName == binding.servingSize.entryName) {
                return@forEach
            }
            val nutrientCompleteName = getCompleteEntryName(view)
            val value = productDetails[nutrientCompleteName]
            if (value != null) {
                view.setText(value)
                view.unitSpinner?.setSelection(getSelectedUnit(nutrientShortName, productDetails[nutrientCompleteName + ApiFields.Suffix.UNIT]))
            }
        }
        //set the values of all the other nutrients if defined and create new row in the tableLayout.
        for ((i, completeNutrientName) in PARAMS_OTHER_NUTRIENTS.withIndex()) {
            if (productDetails[completeNutrientName] == null) continue

            var unitIndex = 0
            var modIndex = 0
            val value = productDetails[completeNutrientName]
            if (productDetails[completeNutrientName + ApiFields.Suffix.UNIT] != null) {
                unitIndex = getPositionInAllUnitArray(productDetails[completeNutrientName + ApiFields.Suffix.UNIT])
            }
            if (productDetails[completeNutrientName + ApiFields.Suffix.MODIFIER] != null) {
                modIndex = getPositionInAllUnitArray(productDetails[completeNutrientName + ApiFields.Suffix.MODIFIER])
            }
            usedNutrientsIndexes.add(i)
            val nutrients = resources.getStringArray(R.array.nutrients_array)
            addNutrientRow(i, nutrients[i], true, value, unitIndex, modIndex)
        }
    }

    /**
     * @param value [ApiFields.Defaults.NUTRITION_DATA_PER_100G] or [ApiFields.Defaults.NUTRITION_DATA_PER_SERVING]
     * @throws IllegalArgumentException if [value] is neither [ApiFields.Defaults.NUTRITION_DATA_PER_100G] nor [ApiFields.Defaults.NUTRITION_DATA_PER_SERVING]
     */
    private fun updateSelectedDataPer(value: String) {
        binding.radioGroup.clearCheck()
        when (value) {
            NUTRITION_DATA_PER_100G -> binding.radioGroup.check(R.id.for100g_100ml)
            NUTRITION_DATA_PER_SERVING -> binding.radioGroup.check(R.id.per_serving)
            else -> throw IllegalArgumentException("Value is neither $NUTRITION_DATA_PER_100G nor $NUTRITION_DATA_PER_SERVING")
        }
        binding.radioGroup.jumpDrawablesToCurrentState()
    }

    /**
     * Loads nutrition image into the ImageView
     *
     * @param path path of the image
     */
    private fun loadNutritionImage(path: String) {
        picasso.load(path)
            .resize(requireContext().dpsToPixel(50), requireContext().dpsToPixel(50))
            .centerInside()
            .into(binding.btnAddImageNutritionFacts, object : Callback {
                override fun onSuccess() {
                    if (!lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) return
                    afterNutritionImgLoaded()
                }

                override fun onError(ex: Exception) {
                    if (!lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) return
                    afterNutritionImgLoaded()
                }
            })
    }

    private fun afterNutritionImgLoaded() {
        binding.imageProgress.visibility = View.GONE
        binding.btnEditImageNutritionFacts.visibility = View.VISIBLE
    }

    private fun getSelectedUnit(i: Int) = NUTRIENTS_UNITS[i]

    /**
     * @param unit The unit corresponding to which the index is to be returned.
     * @return returns the index to be set to the spinner.
     */
    private fun getPositionInAllUnitArray(unit: String?) =
        NUTRIENTS_UNITS.indexOfFirst { it.equals(unit, true) }.coerceAtLeast(0)

    private fun getPositionInModifierArray(mod: String) =
        MODIFIERS.indexOfFirst { it == mod }.coerceAtLeast(0)

    private fun getPositionInServingUnitArray(unit: String) =
        SERVING_UNITS.indexOfFirst { it.equals(unit, ignoreCase = true) }.coerceAtLeast(0)

    private fun addNutritionFactsImage() {
        val path = imagePath
        if (path == null) {
            newNutritionFactsImage()
            return
        }
        if (photoFile != null) {
            cropRotateImage(photoFile!!, getString(R.string.nutrition_facts_picture))
        } else {
            lifecycleScope.launch(Dispatchers.IO) {
                val uri = download(requireContext(), path, client).awaitSingleOrNull() ?: return@launch
                withContext(Dispatchers.Main) {
                    photoFile = uri.toFile()
                    cropRotateImage(uri, getString(R.string.nutrition_facts_picture))
                }
            }

        }
    }

    private fun newNutritionFactsImage() = doChooseOrTakePhotos()

    override fun doOnPhotosPermissionGranted() = newNutritionFactsImage()

    private fun updateNextBtnState() {
        val allValuesValid = allValid()
        binding.globalValidationMsg.visibility = if (allValuesValid) View.GONE else View.VISIBLE
        binding.btnAdd.isEnabled = allValuesValid
    }

    private fun CustomValidatingEditTextView.checkValue(value: Float) = sequenceOf(
        checkPh(value),
        checkAlcohol(value),
        checkEnergyField(value),
        checkCarbohydrate(value),
        checkPerServing()
    ).firstOrNull { it != ValueState.NOT_TESTED } ?: this.checkAsGram(value)

    private fun CustomValidatingEditTextView.checkAsGram(value: Float): ValueState {
        val valid = convertToGrams(value, unitSpinner!!.selectedItemPosition) <= referenceValueInGram
        return if (!valid) {
            this.showError(getString(R.string.max_nutrient_val_msg))
            ValueState.NOT_VALID
        } else ValueState.VALID
    }

    private fun CustomValidatingEditTextView.checkValue() {
        val wasValid = isError()
        //if no value, we suppose it's valid
        if (isBlank()) {
            cancelError()
            // If per serving is set must be not blank
            checkPerServing()
        } else {
            val value = this.getFloatValue()
            if (value == null) {
                showError(getString(R.string.error_nutrient_entry))
            } else {
                val valueState = this.checkValue(value)
                if (valueState == ValueState.VALID) {
                    cancelError()
                }
            }
        }
        if (wasValid != isValid()) {
            updateNextBtnState()
        }
    }

    private fun CustomValidatingEditTextView.checkValueAndRelated() {
        checkValue()
        if (isCarbohydrateRelated(this)) {
            binding.carbohydrates.checkValue()
        }
        if (binding.servingSize.entryName == entryName) {
            checkAllValues()
        }
    }

    private fun CustomValidatingEditTextView.addValidListener() {
        val textWatcher = ValidTextWatcher(this)
        addTextChangedListener(textWatcher)
        unitSpinner?.onItemSelectedListener = textWatcher
    }

    private fun updateSodiumValue() {
        if (requireActivity().currentFocus === binding.salt) {
            val saltValue = binding.salt.getDoubleValue()
            if (saltValue != null) {
                val sodiumValue = UnitUtils.saltToSodium(saltValue)
                binding.sodium.setText(getRoundNumber(sodiumValue))
            }
        }
    }

    private fun updateSaltValue() {
        if (requireActivity().currentFocus === binding.sodium) {
            val sodiumValue = binding.sodium.getDoubleValue()
            if (sodiumValue != null) {
                val saltValue = UnitUtils.sodiumToSalt(sodiumValue)
                binding.salt.setText(getRoundNumber(saltValue))
            }
        }
    }

    /**
     * adds only those fields to the query map which are not empty.
     */
    override fun addUpdatedFieldsToMap(targetMap: MutableMap<String, String?>) {

        // Add no nutrition data entry to map
        if (binding.checkboxNoNutritionData.isChecked) {
            targetMap[ApiFields.Keys.NO_NUTRITION_DATA] = "on"
        } else {
            addNutrientsModeToMap(targetMap)
        }

        // Add serving size entry to map if it has been changed
        if (binding.servingSize.isNotEmpty()) {
            @Suppress("USELESS_ELVIS") val servingSizeValue = binding.servingSize.getContent() +
            binding.servingSize.unitSpinner!!.selectedItem?.toString() ?: ""
            if (product == null || servingSizeValue != product!!.servingSize) {
                targetMap[ApiFields.Keys.SERVING_SIZE] = servingSizeValue
            }
        }

        // For every nutrition field add it to map if updated
        allEditViews.forEach {
            if (binding.servingSize.entryName == it.entryName) return@forEach
            if (it.isNotEmpty()) {
                addNutrientToMapIfUpdated(it, targetMap)
            }
        }
    }

    /**
     * adds all the fields to the query map even those which are null or empty.
     */
    private fun addAllFieldsToMap(targetMap: MutableMap<String, String?>) {
        if (activity !is ProductEditActivity) return

        val noData = binding.checkboxNoNutritionData.isChecked
        if (noData) {
            targetMap[ApiFields.Keys.NO_NUTRITION_DATA] = "on"
            return
        }
        val servingSizeValue =
            if (binding.servingSize.text == null || binding.servingSize.text.toString().isEmpty()) ""
            else {
                @Suppress("USELESS_ELVIS")
                binding.servingSize.text.toString() + binding.servingSize.unitSpinner?.selectedItem ?: ""
            }
        targetMap[ApiFields.Keys.SERVING_SIZE] = servingSizeValue
        allEditViews.forEach {
            if (binding.servingSize.entryName == it.entryName) return@forEach
            addNutrientToMap(it, targetMap)
        }
    }

    /**
     * Add nutrients to the map by from the text entered into EditText, only if the value has been edited
     *
     * @param editTextView EditText with spinner for entering the nutrients
     * @param targetMap map to enter the nutrient value recieved from edit texts
     */
    private fun addNutrientToMapIfUpdated(
        editTextView: CustomValidatingEditTextView,
        targetMap: MutableMap<String, String?>
    ) {
        val productNutriments = product?.nutriments ?: Nutriments()

        val shortName = editTextView.entryName
        val oldProductNutriment = productNutriments[shortName]

        var oldValue: String? = null
        var oldUnit: String? = null
        var oldMod: String? = null

        if (oldProductNutriment != null) {
            oldUnit = oldProductNutriment.unit
            oldMod = oldProductNutriment.modifier
            oldValue = if (isDataPer100g)
                oldProductNutriment.for100gInUnits
            else
                oldProductNutriment.forServingInUnits
        }
        val valueChanged = editTextView.isContentDifferent(oldValue)

        // Check unit and modifier for changes
        var newUnit: String? = null
        var newMod: String? = null

        if (editTextView.hasUnit()) {
            editTextView.unitSpinner?.let {
                newUnit = getSelectedUnit(it.selectedItemPosition)
            }
        }

        editTextView.modSpinner?.let {
            newMod = it.selectedItem.toString()
        }

        val unitChanged = oldUnit == null || oldUnit != newUnit
        val modChanged = oldMod == null || oldMod != newMod

        if (valueChanged || unitChanged || modChanged) {
            addNutrientToMap(editTextView, targetMap)
        }
    }

    /**
     * Add nutrients to the map by from the text entered into EditText
     *
     * @param editTextView EditText with spinner for entering the nutrients
     * @param targetMap map to enter the nutrient value received from edit texts
     */
    private fun addNutrientToMap(
        editTextView: CustomValidatingEditTextView,
        targetMap: MutableMap<String, String?>
    ) {
        // For impl reference, see https://wiki.openfoodfacts.org/Nutrients_handling_in_Open_Food_Facts#Data_display
        val fieldName = getCompleteEntryName(editTextView)

        // Add unit field {nutrient-id}_unit to map
        if (editTextView.hasUnit() && editTextView.unitSpinner != null) {
            val selectedUnit = getSelectedUnit(editTextView.unitSpinner!!.selectedItemPosition)
            targetMap[fieldName + ApiFields.Suffix.UNIT] = Html.escapeHtml(selectedUnit)
        }

        // Take modifier from attached spinner, add to value if not the default one
        var mod = ""
        if (editTextView.modSpinner != null) {
            val selectedMod = editTextView.modSpinner!!.selectedItem.toString()
            if (DEFAULT_MODIFIER != selectedMod) {
                mod = selectedMod
            }
        }
        // The suffix can either be _serving or _100g depending on user input
        val value = editTextView.text!!.toString()
        targetMap[fieldName] = mod + value
    }

    private fun addNutrientsModeToMap(targetMap: MutableMap<String, String?>) {
        if (isDataPer100g) {
            targetMap[ApiFields.Keys.NUTRITION_DATA_PER] = NUTRITION_DATA_PER_100G
        } else if (isDataPerServing) {
            targetMap[ApiFields.Keys.NUTRITION_DATA_PER] = NUTRITION_DATA_PER_SERVING
        }
    }

    private val isDataPerServing: Boolean
        get() = viewModel.dataFormat.value == R.id.per_serving

    private val isDataPer100g: Boolean
        get() = viewModel.dataFormat.value == R.id.for100g_100ml

    private val referenceValueInGram: Float
        get() {
            var reference = 100f
            if (binding.radioGroup.checkedRadioButtonId != R.id.for100g_100ml) {
                reference = binding.servingSize.getFloatValueOr(reference)
                reference = UnitUtils.convertToGrams(reference, SERVING_UNITS[binding.servingSize.unitSpinner!!.selectedItemPosition])
            }
            return reference
        }

    private fun displayAddNutrientDialog() {
        val nutrients = resources.getStringArray(R.array.nutrients_array)
            .mapIndexedNotNull { index, nutrient ->
                if (usedNutrientsIndexes.contains(index)) null else nutrient
            }
            .sortedWith(Collator.getInstance(Locale.getDefault()))

        MaterialDialog.Builder(requireActivity())
            .title(R.string.choose_nutrient)
            .items(nutrients)
            .itemsCallback { _, _, _, text ->
                usedNutrientsIndexes.add(nutrients.indexOf(text))
                val textView = addNutrientRow(nutrients.indexOf(text), text.toString())

                allEditViews.add(textView)
                textView.addValidListener()
            }
            .show()
    }

    /**
     * Adds a new row in the tableLayout.
     *
     * @param index The index of the additional nutrient to add in the "PARAM_OTHER_NUTRIENTS" array.
     * @param hint The hint text to be displayed in the EditText.
     * @param preFillValues true if the created row needs to be filled by a predefined value.
     * @param value This value will be set to the EditText. Required if 'preFillValues' is true.
     * @param unitSelectedIndex This spinner will be set to this position. Required if 'preFillValues' is true.
     */
    private fun addNutrientRow(
        index: Int,
        hint: String,
        preFillValues: Boolean = false,
        value: String? = null,
        unitSelectedIndex: Int = 0,
        modSelectedIndex: Int = 0
    ): CustomValidatingEditTextView {
        val nutrientCompleteName = PARAMS_OTHER_NUTRIENTS[index]

        val rowView = layoutInflater.inflate(R.layout.nutrition_facts_table_row, binding.tableLayout, false) as TableRow

        // Set hint
        rowView.findViewById<TextInputLayout>(R.id.value_til).hint = hint

        val nutrientShortName = getShortName(nutrientCompleteName)

        val editText = rowView.findViewById<CustomValidatingEditTextView>(R.id.value)
        editText.entryName = nutrientShortName
        editText.keyListener = keyListener

        lastEditText!!.nextFocusDownId = editText.id
        lastEditText!!.imeOptions = EditorInfo.IME_ACTION_NEXT
        lastEditText = editText

        editText.imeOptions = EditorInfo.IME_ACTION_DONE
        editText.requestFocus()

        if (preFillValues) editText.setText(value)

        // Setup unit spinner
        val unitSpinner = rowView.findViewById<Spinner>(R.id.spinner_unit)
        val modSpinner = rowView.findViewById<Spinner>(R.id.spinner_mod)

        when (nutrientShortName) {
            Nutriments.PH -> {
                unitSpinner.visibility = View.INVISIBLE
            }
            Nutriments.STARCH -> {
                val arrayAdapter =
                    ArrayAdapter(requireActivity(), android.R.layout.simple_spinner_item, requireActivity().resources.getStringArray(R.array.weights_array))
                arrayAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
                unitSpinner.adapter = arrayAdapter
                starchEditText = editText
            }
            Nutriments.VITAMIN_A, Nutriments.VITAMIN_D, Nutriments.VITAMIN_E -> {
                val adapter = ArrayAdapter(
                    requireActivity(),
                    android.R.layout.simple_spinner_item,
                    requireActivity().resources.getStringArray(R.array.weight_all_units)
                )
                adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
                unitSpinner.adapter = adapter
            }
        }
        try {
            if (preFillValues) {
                unitSpinner.setSelection(unitSelectedIndex)
                modSpinner.setSelection(modSelectedIndex)
            }
        } catch (t: Exception) {
            sentryAnalytics.record(IllegalStateException("Can't find weight units for nutriment: $nutrientShortName", t))
            closeScreenWithAlert()
        }

        binding.tableLayout.addView(rowView)
        return editText
    }

    private fun closeScreenWithAlert() {
        Toast.makeText(requireContext(), R.string.error_adding_nutrition_facts, Toast.LENGTH_SHORT).show()
        requireActivity().finish()
    }

    private fun isCarbohydrateRelated(editText: CustomValidatingEditTextView): Boolean {
        val entryName = editText.entryName
        return binding.sugars.entryName == entryName || starchEditText != null && entryName == starchEditText!!.entryName
    }

    /**
     * Validate the value of carbohydrate using carbs value and sugar value
     * @param value quality value with known prefix
     */
    private fun CustomValidatingEditTextView.checkCarbohydrate(value: Float): ValueState {
        if (binding.carbohydrates.entryName != entryName) return ValueState.NOT_TESTED

        val res = this.checkAsGram(value)

        if (ValueState.NOT_VALID == res) return res

        var carbsValue = binding.carbohydrates.getFloatValueOr(0f)
        var sugarValue = binding.sugars.getFloatValueOr(0f)

        // Check that value of (sugar + starch) is not greater than value of carbohydrates
        // Convert all the values to grams
        carbsValue = convertToGrams(carbsValue, binding.carbohydrates.unitSpinner!!.selectedItemPosition)
        sugarValue = convertToGrams(sugarValue, binding.sugars.unitSpinner!!.selectedItemPosition)

        val newStarch = convertToGrams(starchValue, starchUnitSelectedIndex).toDouble()

        return if (sugarValue + newStarch > carbsValue) {
            binding.carbohydrates.showError(getString(R.string.error_in_carbohydrate_value))
            ValueState.NOT_VALID
        } else ValueState.VALID
    }

    /**
     * Validate serving size value entered by user
     */
    private fun CustomValidatingEditTextView.checkPerServing(): ValueState {
        return if (binding.servingSize.entryName == entryName) {
            if (isDataPer100g) {
                return ValueState.VALID
            }
            val value = binding.servingSize.getFloatValueOr(0f)
            if (value <= 0) {
                showError(getString(R.string.error_nutrient_serving_data))
                return ValueState.NOT_VALID
            }
            ValueState.VALID
        } else ValueState.NOT_TESTED
    }

    /**
     * Validate oh value according to [Nutriments.PH]
     * @param value quality value with known prefix
     */
    private fun CustomValidatingEditTextView.checkPh(value: Float): ValueState {
        return if (Nutriments.PH == entryName) {
            val maxPhValue = 14.0
            if (value > maxPhValue || value >= maxPhValue && this.isModifierEqualsToGreaterThan()) {
                setText(maxPhValue.toString())
            }
            ValueState.VALID
        } else ValueState.NOT_TESTED
    }

    /**
     * Validate energy value entered by user
     */
    private fun CustomValidatingEditTextView.checkEnergyField(value: Float): ValueState {
        when (entryName) {
            binding.energyKcal.entryName -> {
                var energyInKcal = value
                if (binding.radioGroup.checkedRadioButtonId != R.id.for100g_100ml) {
                    energyInKcal *= 100.0f / referenceValueInGram
                }
                val isValid = energyInKcal <= 2000f
                if (!isValid) {
                    showError(getString(R.string.max_energy_val_msg))
                }
                return if (isValid) ValueState.VALID else ValueState.NOT_VALID
            }
            binding.energyKj.entryName -> {
                var energyInKj = value
                if (binding.radioGroup.checkedRadioButtonId != R.id.for100g_100ml) {
                    energyInKj *= 100.0f / referenceValueInGram
                }
                val isValid = energyInKj <= 8368000f
                if (!isValid) {
                    showError(getString(R.string.max_energy_val_msg))
                }
                return if (isValid) ValueState.VALID else ValueState.NOT_VALID
            }
            else -> return ValueState.NOT_TESTED
        }
    }

    /**
     * validate alcohol content entered by user
     */
    private fun CustomValidatingEditTextView.checkAlcohol(value: Float) =
        if (binding.alcohol.entryName == entryName) {
            if (value > 100) {
                showError("This value is over 100")
                ValueState.NOT_VALID
            } else ValueState.VALID
        } else ValueState.NOT_TESTED

    override fun showImageProgress() {
        if (!isAdded) return
        binding.imageProgress.visibility = View.VISIBLE
        binding.imageProgressText.visibility = View.VISIBLE
        binding.btnAddImageNutritionFacts.visibility = View.INVISIBLE
        binding.btnEditImageNutritionFacts.visibility = View.INVISIBLE
    }

    private val starchValue
        get() = if (starchEditText == null) 0F else starchEditText!!.getFloatValue() ?: 0F


    private val starchUnitSelectedIndex
        get() = if (starchEditText == null) 0 else starchEditText!!.unitSpinner!!.selectedItemPosition

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        photoReceiverHandler.onActivityResult(this, requestCode, resultCode, data)
    }

    override fun hideImageProgress(errorInUploading: Boolean, message: String) {
        if (!isAdded) return
        binding.imageProgress.visibility = View.GONE
        binding.imageProgressText.visibility = View.GONE
        binding.btnAddImageNutritionFacts.visibility = View.VISIBLE
        binding.btnEditImageNutritionFacts.visibility = View.VISIBLE
        if (!errorInUploading) {
            picasso.load(photoFile!!)
                .resize(requireContext().dpsToPixel(50), requireContext().dpsToPixel(50))
                .centerInside()
                .into(binding.btnAddImageNutritionFacts)
        }
    }

    internal inner class ValidTextWatcher(private val editTextView: CustomValidatingEditTextView) : TextWatcher, OnItemSelectedListener {
        override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) = Unit // Nothing to do

        override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) = Unit // Nothing to do

        override fun afterTextChanged(s: Editable) = editTextView.checkValueAndRelated()
        override fun onNothingSelected(parent: AdapterView<*>?) = editTextView.checkValueAndRelated()

        override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
            editTextView.checkValueAndRelated()
            if (binding.salt.entryName == editTextView.entryName) {
                binding.sodium.unitSpinner!!.setSelection(binding.salt.unitSpinner!!.selectedItemPosition)
            }
            if (binding.sodium.entryName == editTextView.entryName) {
                binding.salt.unitSpinner!!.setSelection(binding.sodium.unitSpinner!!.selectedItemPosition)
            }
        }
    }

    companion object {
        private val NUTRIENTS_UNITS = listOf(UNIT_GRAM, UNIT_MILLIGRAM, UNIT_MICROGRAM, UNIT_DV, UNIT_IU)
        private val SERVING_UNITS = listOf(UNIT_GRAM, UNIT_MILLIGRAM, UNIT_MICROGRAM, UNIT_LITER, UNIT_MILLILITRE)

        /**
         * Converts a given quantity's unit to grams.
         *
         * @param value The value to be converted
         * @param index 1 represents milligrams, 2 represents micrograms
         * @return return the converted value
         */
        private fun convertToGrams(value: Float, index: Int): Float {
            val unit = NUTRIENTS_UNITS[index]
            // Can't be converted to grams.
            return if (UNIT_DV == unit || UNIT_IU == unit) 0F
            else UnitUtils.convertToGrams(value, unit)
        }
    }
}