package ana

import (
	"maps"
	"math"
	"regexp"
	"time"

	"gogs.inhome.blapointe.com/ana-ledger/ledger"
)

type Predictor func(ledger.Balances, time.Duration) ledger.Balances

func NewInterestPredictor(namePattern string, currencyPattern string, apy float64) Predictor {
	nameMatcher := regexp.MustCompile(namePattern)
	currencyMatcher := regexp.MustCompile(currencyPattern)
	return func(given ledger.Balances, delta time.Duration) ledger.Balances {
		result := maps.Clone(given)
		for k, v := range result {
			result[k] = maps.Clone(v)
		}

		monthsPassed := float64(delta) / float64(time.Hour*24.0*365.0/12.0)
		scalar := math.Pow(1.0+apy/12.0, monthsPassed)
		for name := range result {
			if !nameMatcher.MatchString(name) {
				continue
			}
			for currency := range result[name] {
				if !currencyMatcher.MatchString(string(currency)) {
					continue
				}
				result[name][currency] *= scalar
			}
		}
		return result
	}
}

func NewContributionPredictor(reg ledger.Register) Predictor {
	monthlyRate := getMonthlyContributionRates(reg)
	return newContributionPredictor(monthlyRate)
}

func newContributionPredictor(monthlyRate map[string]ledger.Balance) Predictor {
	return func(given ledger.Balances, delta time.Duration) ledger.Balances {
		month := time.Hour * 24 * 365 / 12
		months := float64(delta) / float64(month)
		result := make(ledger.Balances)
		for k, v := range given {
			result[k] = maps.Clone(v)
		}
		for name := range monthlyRate {
			if _, ok := result[name]; !ok {
				result[name] = make(ledger.Balance)
			}
			for currency := range monthlyRate[name] {
				result[name][currency] += monthlyRate[name][currency] * months
			}
		}
		return result
	}
}

func getMonthlyContributionRates(reg ledger.Register) map[string]ledger.Balance {
	window := time.Hour * 24 * 365 / 2
	contributions := getRecentContributions(reg, window)
	result := make(map[string]ledger.Balance)
	for name := range contributions {
		result[name] = getMonthlyContributionRate(contributions[name], window, name)
	}
	return result
}

// TODO better than average
func getMonthlyContributionRate(contributions []ledger.Balance, window time.Duration, name string) ledger.Balance {
	sumPerCurrency := map[ledger.Currency]float64{}
	for _, balance := range contributions {
		for currency, v := range balance {
			sumPerCurrency[currency] += v
		}
	}
	result := make(ledger.Balance)
	for currency, summed := range sumPerCurrency {
		result[currency] = summed / (float64(window) / float64(time.Hour*24.0*365.0/12.0))
	}
	return result
}

func getRecentContributions(reg ledger.Register, window time.Duration) map[string][]ledger.Balance {
	return getContributions(reg.Between(time.Now().Add(-1*window), time.Now()))
}

func getContributions(reg ledger.Register) map[string][]ledger.Balance {
	contributions := make(map[string][]ledger.Balance)
	for _, name := range reg.Names() {
		contributions[name] = getContributionsFor(reg, name)
	}
	return contributions
}

func getContributionsFor(reg ledger.Register, name string) []ledger.Balance {
	result := make([]ledger.Balance, 0)
	var last ledger.Balance
	for _, date := range reg.Dates() {
		if _, ok := reg[date][name]; !ok {
			continue
		}

		if last == nil {
			last = reg[date][name]
			continue
		}

		result = append(result, make(ledger.Balance))
		this := result[len(result)-1]

		for k, v := range last {
			this[k] = -1 * v
		}
		for k, v := range reg[date][name] {
			this[k] += v
		}

		last = reg[date][name]
	}
	return result
}