feat: Limit number of char values

Author: ErikKalkoken

internal/app/ui/wealth.go

@@ -1,6 +1,7 @@
 package ui
 
 import (
+	"cmp"
 	"context"
 	"fmt"
 	"image/color"
@@ -18,32 +19,38 @@ import (
 
 	"github.com/ErikKalkoken/evebuddy/internal/app"
 	ihumanize "github.com/ErikKalkoken/evebuddy/internal/humanize"
+	"github.com/ErikKalkoken/evebuddy/internal/xslices"
 )
 
 type wealth struct {
 	widget.BaseWidget
 
 	onUpdate func(wallet, assets float64)
 
-	breakdown  *coord.CartesianCategoricalChart
-	characters *prop.PieChart
-	top        *widget.Label
-	types      *prop.PieChart
-	u          *baseUI
+	assetDetail  *coord.CartesianCategoricalChart
+	assetSplit   *prop.PieChart
+	top          *widget.Label
+	u            *baseUI
+	walletDetail *coord.CartesianCategoricalChart
+	walletSplit  *prop.PieChart
 }
 
 func newWealth(u *baseUI) *wealth {
 	a := &wealth{
-		breakdown:  coord.NewCartesianCategoricalChart("Wealth Breakdown By Character in B ISK"),
-		characters: prop.NewPieChart("Total Wealth By Character in B ISK"),
-		top:        makeTopLabel(),
-		types:      prop.NewPieChart("Total Wealth By Type"),
-		u:          u,
+		assetDetail:  coord.NewCartesianCategoricalChart(""),
+		assetSplit:   prop.NewPieChart(""),
+		top:          makeTopLabel(),
+		u:            u,
+		walletDetail: coord.NewCartesianCategoricalChart(""),
+		walletSplit:  prop.NewPieChart(""),
 	}
 	a.ExtendBaseWidget(a)
-	a.breakdown.SetTitleStyle(theme.SizeNameSubHeadingText, theme.ColorNameForeground)
-	a.characters.SetTitleStyle(theme.SizeNameSubHeadingText, theme.ColorNameForeground)
-	a.types.SetTitleStyle(theme.SizeNameSubHeadingText, theme.ColorNameForeground)
+	a.assetDetail.SetTitleStyle(theme.SizeNameSubHeadingText, theme.ColorNameForeground)
+	a.assetDetail.HideLegend()
+	a.assetSplit.SetTitleStyle(theme.SizeNameSubHeadingText, theme.ColorNameForeground)
+	a.walletSplit.SetTitleStyle(theme.SizeNameSubHeadingText, theme.ColorNameForeground)
+	a.walletDetail.SetTitleStyle(theme.SizeNameSubHeadingText, theme.ColorNameForeground)
+	a.walletDetail.HideLegend()
 
 	a.u.characterSectionChanged.AddListener(func(_ context.Context, arg characterSectionUpdated) {
 		switch arg.section {
@@ -56,27 +63,20 @@ func newWealth(u *baseUI) *wealth {
 			a.update()
 		}
 	})
-
 	return a
 }
 
 func (a *wealth) CreateRenderer() fyne.WidgetRenderer {
-	var total *fyne.Container
-	if a.u.isDesktop {
-		total = container.NewGridWithColumns(2, a.types, a.characters)
-	} else {
-		total = container.NewAdaptiveGrid(2, a.types, a.characters)
-	}
-	charts := container.NewAppTabs(
-		container.NewTabItem("Total", total),
-		container.NewTabItem("Breakdown", a.breakdown),
-	)
 	c := container.NewBorder(
 		a.top,
 		nil,
 		nil,
 		nil,
-		container.NewScroll(charts),
+		container.NewAppTabs(
+			container.NewTabItem("Distribution", container.NewAdaptiveGrid(2, a.assetSplit, a.walletSplit)),
+			container.NewTabItem("Assets", a.assetDetail),
+			container.NewTabItem("Wallets", a.walletDetail),
+		),
 	)
 	return widget.NewSimpleRenderer(c)
 }
@@ -101,106 +101,188 @@ func (a *wealth) update() {
 		return
 	}
 
-	colors := newColorWheel()
-	// type
+	const maxCharacters = 7
 	var totalWallet, totalAssets float64
 	for _, r := range data {
 		totalAssets += r.assets
 		totalWallet += r.wallet
 	}
-	s1, err := prop.NewSeries("Type", []chartData.ProportionalPoint{{
-		C:   "Assets",
-		Val: totalAssets,
-		Col: colors.next(),
-	}, {
-		C:   "Wallets",
-		Val: totalWallet,
-		Col: colors.next(),
-	}})
+	colors := newColorWheel()
+
+	// totals
+	totalText := ihumanize.Number(totalAssets+totalWallet, 1)
+	fyne.Do(func() {
+		a.top.Text = fmt.Sprintf("%s ISK total wealth • %d characters", totalText, characters)
+		a.top.Importance = widget.MediumImportance
+		a.top.Refresh()
+	})
+
+	if a.onUpdate != nil {
+		a.onUpdate(totalWallet, totalAssets)
+	}
+
+	// total
+	// s3, err := prop.NewSeries("", []chartData.ProportionalPoint{
+	// 	{
+	// 		C:   "Assets",
+	// 		Val: totalAssets,
+	// 		Col: colors.next(),
+	// 	},
+	// 	{
+	// 		C:   "Wallets",
+	// 		Val: totalWallet,
+	// 		Col: colors.next(),
+	// 	},
+	// })
+	// fyne.Do(func() {
+	// 	a.total.RemoveSeries("")
+	// 	err = a.total.AddSeries(s3)
+	// 	if err != nil {
+	// 		panic(err)
+	// 	}
+	// 	a.wallets.SetTitle(fmt.Sprintf("Wealth - Total: %.1f B ISK", totalWallet+totalAssets))
+	// })
+
+	// Asset splits
+	d1 := xslices.Map(data, func(r dataRow) chartData.ProportionalPoint {
+		return chartData.ProportionalPoint{
+			C:   r.label,
+			Val: r.assets,
+			Col: colors.next(),
+		}
+	})
+	d1 = reduceProportionalPoints(d1, maxCharacters)
+	s1, err := prop.NewSeries("Characters", d1)
 	if err != nil {
 		panic(err)
 	}
 	fyne.Do(func() {
-		a.types.RemoveSeries("Type")
-		err = a.types.AddSeries(s1)
+		a.assetSplit.RemoveSeries("Characters")
+		err = a.assetSplit.AddSeries(s1)
 		if err != nil {
 			panic(err)
 		}
+		a.assetSplit.SetTitle(fmt.Sprintf("Assets By Character - Total: %.1f B ISK", totalAssets))
 	})
 
-	// characters
+	// Wallet split
 	colors.reset()
-	d1 := make([]chartData.ProportionalPoint, 0)
-	for _, r := range data {
-		d1 = append(d1, chartData.ProportionalPoint{
+	d2 := xslices.Map(data, func(r dataRow) chartData.ProportionalPoint {
+		return chartData.ProportionalPoint{
 			C:   r.label,
-			Val: r.total,
+			Val: r.wallet,
 			Col: colors.next(),
-		})
+		}
+	})
+	d2 = reduceProportionalPoints(d2, maxCharacters)
+	s2, err := prop.NewSeries("Characters", d2)
+	if err != nil {
+		panic(err)
 	}
-	s2, err := prop.NewSeries("Characters", d1)
 	fyne.Do(func() {
-		a.characters.RemoveSeries("Characters")
-		err = a.characters.AddSeries(s2)
+		a.walletSplit.RemoveSeries("Characters")
+		err = a.walletSplit.AddSeries(s2)
 		if err != nil {
 			panic(err)
 		}
+		a.walletSplit.SetTitle(fmt.Sprintf("Wallets By Character - Total: %.1f B ISK", totalWallet))
 	})
 
-	// Breakdown
-	d3 := make([]chartData.CategoricalPoint, 0)
-	for _, r := range data {
-		d3 = append(d3, chartData.CategoricalPoint{
+	// Assets detail
+	colors.reset()
+	d4 := xslices.Map(data, func(r dataRow) chartData.CategoricalPoint {
+		return chartData.CategoricalPoint{
 			C:   r.label,
 			Val: r.assets,
-		})
-	}
-	s3, err := coord.NewCategoricalPointSeries("Assets", theme.Color(theme.ColorNameSuccess), d3)
+		}
+	})
+	d4 = reduceCategoricalPoints(d4, maxCharacters)
+	s4, err := coord.NewCategoricalPointSeries("Characters", colors.next(), d4)
 	if err != nil {
 		panic(err)
 	}
-	d4 := make([]chartData.CategoricalPoint, 0)
-	for _, r := range data {
-		d4 = append(d4, chartData.CategoricalPoint{
+	fyne.Do(func() {
+		a.assetDetail.RemoveSeries("Characters")
+		err = a.assetDetail.AddBarSeries(s4)
+		if err != nil {
+			panic(err)
+		}
+		a.assetDetail.SetTitle(fmt.Sprintf("Assets By Character - Total: %.1f B ISK", totalAssets))
+	})
+
+	// Wallet details
+	colors.reset()
+	d3 := xslices.Map(data, func(r dataRow) chartData.CategoricalPoint {
+		return chartData.CategoricalPoint{
 			C:   r.label,
 			Val: r.wallet,
-		})
-	}
-	s4, err := coord.NewCategoricalPointSeries("Wallets", theme.Color(theme.ColorNameError), d4)
+		}
+	})
+	d3 = reduceCategoricalPoints(d3, maxCharacters)
+	s3, err := coord.NewCategoricalPointSeries("Characters", colors.next(), d3)
 	if err != nil {
 		panic(err)
 	}
-
 	fyne.Do(func() {
-		a.breakdown.RemoveSeries("Assets")
-		a.breakdown.RemoveSeries("Wallets")
-		err = a.breakdown.AddBarSeries(s3)
+		a.walletDetail.RemoveSeries("Characters")
+		err = a.walletDetail.AddBarSeries(s3)
 		if err != nil {
 			panic(err)
 		}
-		err = a.breakdown.AddBarSeries(s4)
-		if err != nil {
-			panic(err)
-		}
-		a.breakdown.SetYAxisLabel("B ISK")
+		a.walletDetail.SetTitle(fmt.Sprintf("Wallets By Character - Total: %.1f B ISK", totalWallet))
 	})
 
-	var total float64
-	for _, r := range data {
-		total += r.assets + r.wallet
-	}
-
-	totalText := ihumanize.Number(total, 1)
+}
 
-	fyne.Do(func() {
-		a.top.Text = fmt.Sprintf("%s ISK total wealth • %d characters", totalText, characters)
-		a.top.Importance = widget.MediumImportance
-		a.top.Refresh()
+func reduceProportionalPoints(data []chartData.ProportionalPoint, m int) []chartData.ProportionalPoint {
+	if len(data) <= m {
+		return data
+	}
+	slices.SortFunc(data, func(a, b chartData.ProportionalPoint) int {
+		return cmp.Compare(b.Val, a.Val)
+	})
+	others := data[m].Val
+	if len(data) > m {
+		for _, x := range data[m+1:] {
+			others += x.Val
+		}
+	}
+	data = data[:m]
+	slices.SortFunc(data, func(a, b chartData.ProportionalPoint) int {
+		return strings.Compare(a.C, b.C)
 	})
+	data = append(data,
+		chartData.ProportionalPoint{
+			C:   "Others",
+			Val: others,
+			Col: theme.Color(theme.ColorNameDisabled),
+		})
+	return data
+}
 
-	if a.onUpdate != nil {
-		a.onUpdate(totalWallet, totalAssets)
+func reduceCategoricalPoints(data []chartData.CategoricalPoint, m int) []chartData.CategoricalPoint {
+	if len(data) <= m {
+		return data
 	}
+	slices.SortFunc(data, func(a, b chartData.CategoricalPoint) int {
+		return cmp.Compare(b.Val, a.Val)
+	})
+	others := data[m].Val
+	if len(data) > m {
+		for _, x := range data[m+1:] {
+			others += x.Val
+		}
+	}
+	data = data[:m]
+	slices.SortFunc(data, func(a, b chartData.CategoricalPoint) int {
+		return strings.Compare(a.C, b.C)
+	})
+	data = append(data,
+		chartData.CategoricalPoint{
+			C:   "Others",
+			Val: others,
+		})
+	return data
 }
 
 type dataRow struct {
@@ -270,7 +352,6 @@ func newColorWheel() colorWheel {
 		theme.Color(colorNameSystem),
 		theme.Color(colorNameAttention),
 		theme.Color(theme.ColorNamePlaceHolder),
-		theme.Color(theme.ColorNameDisabled),
 	}
 	return w
 }