package ani.dantotsu.profile import android.os.Bundle import android.view.LayoutInflater import android.view.View import android.view.ViewGroup import android.widget.ArrayAdapter import androidx.fragment.app.Fragment import androidx.lifecycle.lifecycleScope import androidx.recyclerview.widget.LinearLayoutManager import ani.dantotsu.R import ani.dantotsu.connections.anilist.Anilist import ani.dantotsu.connections.anilist.api.Query import ani.dantotsu.databinding.FragmentStatisticsBinding import ani.dantotsu.profile.ChartBuilder.Companion.ChartPacket import ani.dantotsu.profile.ChartBuilder.Companion.ChartType import ani.dantotsu.profile.ChartBuilder.Companion.MediaType import ani.dantotsu.profile.ChartBuilder.Companion.StatType import com.github.aachartmodel.aainfographics.aachartcreator.AAChartType import com.xwray.groupie.GroupieAdapter import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import java.util.Locale class StatsFragment : Fragment() { private lateinit var binding: FragmentStatisticsBinding private var adapter: GroupieAdapter = GroupieAdapter() private var stats: MutableList = mutableListOf() private var type: MediaType = MediaType.ANIME private var statType: StatType = StatType.COUNT private lateinit var user: Query.UserProfile private lateinit var activity: ProfileActivity override fun onCreateView( inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle? ): View { binding = FragmentStatisticsBinding.inflate(inflater, container, false) return binding.root } override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) activity = requireActivity() as ProfileActivity user = arguments?.getSerializable("user") as Query.UserProfile binding.statisticList.adapter = adapter binding.statisticList.setHasFixedSize(true) binding.statisticList.isNestedScrollingEnabled = false binding.statisticList.layoutManager = LinearLayoutManager(requireContext()) binding.statisticProgressBar.visibility = View.VISIBLE binding.compare.visibility = if (user.id == Anilist.userid) View.GONE else View.VISIBLE binding.sourceType.setAdapter( ArrayAdapter( requireContext(), R.layout.item_dropdown, MediaType.entries.map { it.name.uppercase(Locale.ROOT).replace("_", " ") } ) ) binding.sourceFilter.setAdapter( ArrayAdapter( requireContext(), R.layout.item_dropdown, StatType.entries.map { it.name.uppercase(Locale.ROOT).replace("_", " ") } ) ) binding.compare.setOnCheckedChangeListener { _, isChecked -> if (isChecked) { activity.lifecycleScope.launch { if (Anilist.userid != null) { withContext(Dispatchers.Main) { binding.statisticProgressBar.visibility = View.VISIBLE binding.statisticList.visibility = View.GONE } val userStats = Anilist.query.getUserStatistics(Anilist.userid!!)?.data?.user if (userStats != null) { stats.add(userStats) withContext(Dispatchers.Main) { loadStats(type == MediaType.ANIME) binding.statisticProgressBar.visibility = View.GONE binding.statisticList.visibility = View.VISIBLE } } } } } else { stats.removeAll( stats.filter { it?.id == Anilist.userid } ) loadStats(type == MediaType.ANIME) } } binding.filterContainer.visibility = View.GONE activity.lifecycleScope.launch { stats.clear() stats.add(Anilist.query.getUserStatistics(user.id)?.data?.user) withContext(Dispatchers.Main) { binding.filterContainer.visibility = View.VISIBLE binding.sourceType.setOnItemClickListener { _, _, i, _ -> type = MediaType.entries.toTypedArray()[i] loadStats(type == MediaType.ANIME) } binding.sourceFilter.setOnItemClickListener { _, _, i, _ -> statType = StatType.entries.toTypedArray()[i] loadStats(type == MediaType.ANIME) } loadStats(type == MediaType.ANIME) binding.statisticProgressBar.visibility = View.GONE } } } override fun onResume() { super.onResume() if (this::binding.isInitialized) { binding.root.requestLayout() } loadStats(type == MediaType.ANIME) } private fun loadStats(anime: Boolean) { binding.statisticProgressBar.visibility = View.VISIBLE binding.statisticList.visibility = View.GONE adapter.clear() loadFormatChart(anime) loadScoreChart(anime) loadStatusChart(anime) loadReleaseYearChart(anime) loadStartYearChart(anime) loadLengthChart(anime) loadGenreChart(anime) loadTagChart(anime) loadCountryChart(anime) loadVoiceActorsChart(anime) loadStudioChart(anime) loadStaffChart(anime) binding.statisticProgressBar.visibility = View.GONE binding.statisticList.visibility = View.VISIBLE } private fun loadFormatChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.formats?.map { it.format } ?: emptyList() } else { stat?.statistics?.manga?.formats?.map { it.format } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.formats?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.formats?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.formats?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.formats?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.formats?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.formats?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() && values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val formatChart = ChartBuilder.buildChart( activity, ChartType.OneDimensional, AAChartType.Pie, statType, type, chartPackets, xAxisName = "Format", ) adapter.add(ChartItem("Format", formatChart, activity)) } } private fun loadStatusChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.statuses?.map { it.status } ?: emptyList() } else { stat?.statistics?.manga?.statuses?.map { it.status } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.statuses?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.statuses?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.statuses?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.statuses?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.statuses?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.statuses?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() && values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val statusChart = ChartBuilder.buildChart( activity, ChartType.OneDimensional, AAChartType.Funnel, statType, type, chartPackets, xAxisName = "Status", ) adapter.add(ChartItem("Status", statusChart, activity)) } } private fun loadScoreChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.scores?.map { convertScore( it.score, stat.mediaListOptions.scoreFormat ) } ?: emptyList() } else { stat?.statistics?.manga?.scores?.map { convertScore( it.score, stat.mediaListOptions.scoreFormat ) } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.scores?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.scores?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.scores?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.scores?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.scores?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.scores?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val scoreChart = ChartBuilder.buildChart( activity, ChartType.TwoDimensional, AAChartType.Column, statType, type, chartPackets, xAxisName = "Score", ) adapter.add(ChartItem("Score", scoreChart, activity)) } } private fun loadLengthChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.lengths?.map { it.length ?: "unknown" } ?: emptyList() } else { stat?.statistics?.manga?.lengths?.map { it.length ?: "unknown" } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.lengths?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.lengths?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.lengths?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.lengths?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.lengths?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.lengths?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val lengthChart = ChartBuilder.buildChart( activity, ChartType.OneDimensional, AAChartType.Pyramid, statType, type, chartPackets, xAxisName = "Length", ) adapter.add(ChartItem("Length", lengthChart, activity)) } } private fun loadReleaseYearChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.releaseYears?.map { it.releaseYear } ?: emptyList() } else { stat?.statistics?.manga?.releaseYears?.map { it.releaseYear } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.releaseYears?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.releaseYears?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.releaseYears?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.releaseYears?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.releaseYears?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.releaseYears?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val releaseYearChart = ChartBuilder.buildChart( activity, ChartType.TwoDimensional, AAChartType.Bubble, statType, type, chartPackets, xAxisName = "Year", scrollPos = 0.0f ) adapter.add(ChartItem("Release Year", releaseYearChart, activity)) } } private fun loadStartYearChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.startYears?.map { it.startYear } ?: emptyList() } else { stat?.statistics?.manga?.startYears?.map { it.startYear } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.startYears?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.startYears?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.startYears?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.startYears?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.startYears?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.startYears?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val startYearChart = ChartBuilder.buildChart( activity, ChartType.TwoDimensional, AAChartType.Bar, statType, type, chartPackets, xAxisName = "Year", ) adapter.add(ChartItem("Start Year", startYearChart, activity)) } } private fun loadGenreChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.genres?.map { it.genre } ?: emptyList() } else { stat?.statistics?.manga?.genres?.map { it.genre } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.genres?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.genres?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.genres?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.genres?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.genres?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.genres?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val referenceNames = chartPackets.first().names.map { it.toString() } val standardizedPackets = chartPackets.map { packet -> val valuesMap = packet.names.map { it.toString() }.zip(packet.statData).toMap() val standardizedValues = referenceNames.map { name -> valuesMap[name] ?: 0 } // Create a new ChartPacket with standardized names and values. ChartPacket(packet.username, referenceNames, standardizedValues) }.toMutableList() chartPackets.clear() chartPackets.addAll(standardizedPackets) val genreChart = ChartBuilder.buildChart( activity, ChartType.TwoDimensional, AAChartType.Areaspline, statType, type, chartPackets, xAxisName = "Genre", polar = true, passedCategories = chartPackets[0].names as List, normalize = true ) adapter.add(ChartItem("Genre", genreChart, activity)) } } private fun loadTagChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.tags?.map { it.tag.name } ?: emptyList() } else { stat?.statistics?.manga?.tags?.map { it.tag.name } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.tags?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.tags?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.tags?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.tags?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.tags?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.tags?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val referenceNames = chartPackets.first().names.map { it.toString() } val standardizedPackets = chartPackets.map { packet -> val valuesMap = packet.names.map { it.toString() }.zip(packet.statData).toMap() val standardizedValues = referenceNames.map { name -> valuesMap[name] ?: 0 } // Create a new ChartPacket with standardized names and values. ChartPacket(packet.username, referenceNames, standardizedValues) }.toMutableList() chartPackets.clear() chartPackets.addAll(standardizedPackets) val tagChart = ChartBuilder.buildChart( activity, ChartType.TwoDimensional, AAChartType.Areaspline, statType, type, chartPackets, xAxisName = "Tag", polar = false, passedCategories = chartPackets[0].names as List, scrollPos = 0.0f ) adapter.add(ChartItem("Tag", tagChart, activity)) } } private fun loadCountryChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.countries?.map { it.country } ?: emptyList() } else { stat?.statistics?.manga?.countries?.map { it.country } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.countries?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.countries?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.countries?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.countries?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.countries?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.countries?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val referenceNames = chartPackets.first().names.map { it.toString() } val standardizedPackets = chartPackets.map { packet -> val valuesMap = packet.names.map { it.toString() }.zip(packet.statData).toMap() val standardizedValues = referenceNames.map { name -> valuesMap[name] ?: 0 } // Create a new ChartPacket with standardized names and values. ChartPacket(packet.username, referenceNames, standardizedValues) }.toMutableList() chartPackets.clear() chartPackets.addAll(standardizedPackets) val countryChart = ChartBuilder.buildChart( activity, ChartType.OneDimensional, AAChartType.Pie, statType, type, chartPackets, xAxisName = "Country", polar = false, passedCategories = chartPackets[0].names as List, scrollPos = null ) adapter.add(ChartItem("Country", countryChart, activity)) } } private fun loadVoiceActorsChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.voiceActors?.map { it.voiceActor.name.full ?: "unknown" } ?: emptyList() } else { stat?.statistics?.manga?.voiceActors?.map { it.voiceActor.name.full ?: "unknown" } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.voiceActors?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.voiceActors?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.voiceActors?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.voiceActors?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.voiceActors?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.voiceActors?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val referenceNames = chartPackets.first().names.map { it.toString() } val standardizedPackets = chartPackets.map { packet -> val valuesMap = packet.names.map { it.toString() }.zip(packet.statData).toMap() val standardizedValues = referenceNames.map { name -> valuesMap[name] ?: 0 } // Create a new ChartPacket with standardized names and values. ChartPacket(packet.username, referenceNames, standardizedValues) }.toMutableList() chartPackets.clear() chartPackets.addAll(standardizedPackets) val voiceActorsChart = ChartBuilder.buildChart( activity, ChartType.TwoDimensional, AAChartType.Column, statType, type, chartPackets, xAxisName = "Voice Actor", polar = false, passedCategories = chartPackets[0].names as List, scrollPos = 0.0f ) adapter.add(ChartItem("Voice Actor", voiceActorsChart, activity)) } } private fun loadStudioChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.studios?.map { it.studio.name } ?: emptyList() } else { stat?.statistics?.manga?.studios?.map { it.studio.name } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.studios?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.studios?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.studios?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.studios?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.studios?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.studios?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val referenceNames = chartPackets.first().names.map { it.toString() } val standardizedPackets = chartPackets.map { packet -> val valuesMap = packet.names.map { it.toString() }.zip(packet.statData).toMap() val standardizedValues = referenceNames.map { name -> valuesMap[name] ?: 0 } // Create a new ChartPacket with standardized names and values. ChartPacket(packet.username, referenceNames, standardizedValues) }.toMutableList() chartPackets.clear() chartPackets.addAll(standardizedPackets) val studioChart = ChartBuilder.buildChart( activity, ChartType.TwoDimensional, AAChartType.Spline, statType, type, chartPackets, xAxisName = "Studio", polar = true, passedCategories = chartPackets[0].names as List, scrollPos = null, normalize = true ) adapter.add(ChartItem("Studio", studioChart, activity)) } } private fun loadStaffChart(anime: Boolean) { val chartPackets = mutableListOf() stats.forEach { stat -> val names: List = if (anime) { stat?.statistics?.anime?.staff?.map { it.staff.name.full ?: "unknown" } ?: emptyList() } else { stat?.statistics?.manga?.staff?.map { it.staff.name.full ?: "unknown" } ?: emptyList() } val values: List = if (anime) { when (statType) { StatType.COUNT -> stat?.statistics?.anime?.staff?.map { it.count } StatType.TIME -> stat?.statistics?.anime?.staff?.map { it.minutesWatched / 60 } StatType.AVG_SCORE -> stat?.statistics?.anime?.staff?.map { it.meanScore } } ?: emptyList() } else { when (statType) { StatType.COUNT -> stat?.statistics?.manga?.staff?.map { it.count } StatType.TIME -> stat?.statistics?.manga?.staff?.map { it.chaptersRead } StatType.AVG_SCORE -> stat?.statistics?.manga?.staff?.map { it.meanScore } } ?: emptyList() } if (names.isNotEmpty() || values.isNotEmpty()) { chartPackets.add(ChartPacket(stat?.name ?: "Unknown", names, values)) } } if (chartPackets.isNotEmpty()) { val referenceNames = chartPackets.first().names.map { it.toString() } val standardizedPackets = chartPackets.map { packet -> val valuesMap = packet.names.map { it.toString() }.zip(packet.statData).toMap() val standardizedValues = referenceNames.map { name -> valuesMap[name] ?: 0 } // Create a new ChartPacket with standardized names and values. ChartPacket(packet.username, referenceNames, standardizedValues) }.toMutableList() chartPackets.clear() chartPackets.addAll(standardizedPackets) val staffChart = ChartBuilder.buildChart( activity, ChartType.TwoDimensional, AAChartType.Line, statType, type, chartPackets, xAxisName = "Staff", polar = false, passedCategories = chartPackets[0].names as List, scrollPos = 0.0f ) adapter.add(ChartItem("Staff", staffChart, activity)) } } private fun convertScore(score: Int, type: String?): Int { return when (type) { "POINT_100" -> score "POINT_10_DECIMAL" -> score "POINT_10" -> score * 10 "POINT_5" -> score * 20 "POINT_3" -> score * 33 else -> score } } companion object { fun newInstance(user: Query.UserProfile): StatsFragment { val args = Bundle().apply { putSerializable("user", user) } return StatsFragment().apply { arguments = args } } } }