path: root/app/src/main/java/foundation/e/advancedprivacy/features/dashboard/DashboardFragment.kt

/*
 * Copyright (C) 2023 MURENA SAS
 * Copyright (C) 2021 E FOUNDATION
 *
 * 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.
 *
 * This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package foundation.e.advancedprivacy.features.dashboard

import android.os.Bundle
import android.text.Html
import android.text.Html.FROM_HTML_MODE_LEGACY
import android.view.View
import android.widget.Toast
import androidx.core.content.ContextCompat.getColor
import androidx.core.view.isVisible
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.navigation.fragment.findNavController
import androidx.navigation.fragment.navArgs
import foundation.e.advancedprivacy.R
import foundation.e.advancedprivacy.common.GraphHolder
import foundation.e.advancedprivacy.common.NavToolbarFragment
import foundation.e.advancedprivacy.databinding.FragmentDashboardBinding
import foundation.e.advancedprivacy.domain.entities.InternetPrivacyMode
import foundation.e.advancedprivacy.domain.entities.LocationMode
import foundation.e.advancedprivacy.domain.entities.QuickPrivacyState
import foundation.e.advancedprivacy.domain.entities.TrackerMode
import foundation.e.advancedprivacy.features.dashboard.DashboardViewModel.Action
import foundation.e.advancedprivacy.features.dashboard.DashboardViewModel.SingleEvent
import kotlinx.coroutines.launch
import org.koin.androidx.viewmodel.ext.android.viewModel

class DashboardFragment : NavToolbarFragment(R.layout.fragment_dashboard) {
    private val viewModel: DashboardViewModel by viewModel()

    private var graphHolder: GraphHolder? = null

    private var _binding: FragmentDashboardBinding? = null
    private val binding get() = _binding!!

    private var highlightIndexOnStart: Int? = null

    private val args: DashboardFragmentArgs by navArgs()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        highlightIndexOnStart = args.highlightLeaks
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        _binding = FragmentDashboardBinding.bind(view)

        graphHolder = GraphHolder(binding.graph, requireContext())

        binding.leakingAppButton.setOnClickListener {
            viewModel.submitAction(Action.ShowMostLeakedApp)
        }
        binding.toggleTrackers.setOnClickListener {
            viewModel.submitAction(
                Action.ToggleTrackers(
                    enabled = binding.toggleTrackers.isChecked
                )
            )
        }
        binding.toggleLocation.setOnClickListener {
            viewModel.submitAction(
                Action.ToggleLocation(
                    enabled = binding.toggleLocation.isChecked
                )
            )
        }
        binding.toggleIpscrambling.setOnClickListener {
            viewModel.submitAction(
                Action.ToggleIpScrambling(
                    enabled = binding.toggleIpscrambling.isChecked
                )
            )
        }
        binding.myLocation.container.setOnClickListener {
            viewModel.submitAction(Action.ShowFakeMyLocationAction)
        }
        binding.internetActivityPrivacy.container.setOnClickListener {
            viewModel.submitAction(Action.ShowInternetActivityPrivacyAction)
        }
        binding.appsPermissions.container.setOnClickListener {
            viewModel.submitAction(Action.ShowAppsPermissions)
        }

        binding.amITracked.container.setOnClickListener {
            viewModel.submitAction(Action.ShowTrackers)
        }

        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                render(viewModel.state.value)
                viewModel.state.collect(::render)
            }
        }

        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.singleEvents.collect { event ->
                    when (event) {
                        is SingleEvent.ToastMessageSingleEvent ->
                            Toast.makeText(
                                requireContext(),
                                getString(event.message, *event.args.toTypedArray()),
                                Toast.LENGTH_LONG
                            ).show()
                    }
                }
            }
        }
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.navigate.collect(findNavController()::navigate)
            }
        }

        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.doOnStartedState()
            }
        }
    }

    private fun render(state: DashboardState) {
        binding.stateLabel.text = getString(
            when (state.quickPrivacyState) {
                QuickPrivacyState.DISABLED -> R.string.dashboard_state_title_off
                QuickPrivacyState.FULL_ENABLED -> R.string.dashboard_state_title_on
                QuickPrivacyState.ENABLED -> R.string.dashboard_state_title_custom
            }
        )

        binding.stateIcon.setImageResource(
            if (state.quickPrivacyState.isEnabled()) R.drawable.ic_shield_on
            else R.drawable.ic_shield_off
        )

        binding.toggleTrackers.isChecked = state.trackerMode != TrackerMode.VULNERABLE

        binding.stateTrackers.text = getString(
            when (state.trackerMode) {
                TrackerMode.DENIED -> R.string.dashboard_state_trackers_on
                TrackerMode.VULNERABLE -> R.string.dashboard_state_trackers_off
                TrackerMode.CUSTOM -> R.string.dashboard_state_trackers_custom
            }
        )
        binding.stateTrackers.setTextColor(
            getColor(
                requireContext(),
                if (state.trackerMode == TrackerMode.VULNERABLE) R.color.red_off
                else R.color.green_valid
            )
        )

        binding.toggleLocation.isChecked = state.isLocationHidden

        binding.stateGeolocation.text = getString(
            if (state.isLocationHidden) R.string.dashboard_state_geolocation_on
            else R.string.dashboard_state_geolocation_off
        )
        binding.stateGeolocation.setTextColor(
            getColor(
                requireContext(),
                if (state.isLocationHidden) R.color.green_valid
                else R.color.red_off
            )
        )

        binding.toggleIpscrambling.isChecked = state.ipScramblingMode.isChecked
        val isLoading = state.ipScramblingMode.isLoading
        binding.toggleIpscrambling.isEnabled = (
            state.ipScramblingMode != InternetPrivacyMode.REAL_IP_LOADING
            )

        binding.stateIpAddress.text = getString(
            if (state.ipScramblingMode == InternetPrivacyMode.HIDE_IP) R.string.dashboard_state_ipaddress_on
            else R.string.dashboard_state_ipaddress_off
        )

        binding.stateIpAddressLoader.visibility = if (isLoading) View.VISIBLE else View.GONE
        binding.stateIpAddress.visibility = if (!isLoading) View.VISIBLE else View.GONE

        binding.stateIpAddress.setTextColor(
            getColor(
                requireContext(),
                if (state.ipScramblingMode == InternetPrivacyMode.HIDE_IP) R.color.green_valid
                else R.color.red_off
            )
        )

        if (state.dayStatistics?.all { it.first == 0 && it.second == 0 } == true) {
            binding.graph.visibility = View.INVISIBLE
            binding.graphLegend.isVisible = false
            binding.leakingAppButton.isVisible = false
            binding.graphEmpty.isVisible = true
        } else {
            binding.graph.isVisible = true
            binding.graphLegend.isVisible = true
            binding.leakingAppButton.isVisible = true
            binding.graphEmpty.isVisible = false
            state.dayStatistics?.let { graphHolder?.data = it }
            state.dayLabels?.let { graphHolder?.labels = it }
            state.dayGraduations?.let { graphHolder?.graduations = it }

            binding.graphLegend.text = Html.fromHtml(
                getString(
                    R.string.dashboard_graph_trackers_legend,
                    state.leakedTrackersCount?.toString() ?: "No"
                ),
                FROM_HTML_MODE_LEGACY
            )

            highlightIndexOnStart?.let {
                binding.graph.post {
                    graphHolder?.highlightIndex(it)
                }
                highlightIndexOnStart = null
            }
        }

        if (state.allowedTrackersCount != null && state.trackersCount != null) {
            binding.amITracked.subTitle = getString(R.string.dashboard_am_i_tracked_subtitle, state.trackersCount, state.allowedTrackersCount)
        } else {
            binding.amITracked.subTitle = ""
        }

        binding.myLocation.subTitle = getString(
            when (state.locationMode) {
                LocationMode.REAL_LOCATION -> R.string.dashboard_location_subtitle_off
                LocationMode.SPECIFIC_LOCATION -> R.string.dashboard_location_subtitle_specific
                LocationMode.RANDOM_LOCATION -> R.string.dashboard_location_subtitle_random
            }
        )

        binding.internetActivityPrivacy.subTitle = getString(
            if (state.ipScramblingMode == InternetPrivacyMode.HIDE_IP) R.string.dashboard_internet_activity_privacy_subtitle_on
            else R.string.dashboard_internet_activity_privacy_subtitle_off
        )

        binding.executePendingBindings()
    }

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