package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"maps"
	"net/http"
	"os"
	"slices"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/go-echarts/go-echarts/v2/charts"
	"github.com/go-echarts/go-echarts/v2/opts"
	"gogs.inhome.blapointe.com/ana-ledger/ana"
	"gogs.inhome.blapointe.com/ana-ledger/ledger"
)

func main() {
	foo := flag.String("foo", "bal", "bal or reg")
	likeName := flag.String("like-name", ".", "regexp to match")
	likeBefore := flag.String("like-before", "9", "date str to compare")
	likeAfter := flag.String("like-after", "0", "date str to compare")
	likeLedger := flag.Bool("like-ledger", false, "limit data to these -like-* rather than zoom to these -like-*")
	groupName := flag.String("group-name", ".*", "grouping to apply to names")
	groupDate := flag.String("group-date", ".*", "grouping to apply to dates")
	bpiPath := flag.String("bpi", "/dev/null", "bpi file")
	jsonOutput := flag.Bool("json", false, "json output")
	httpOutput := flag.String("http", "", "http output listen address, like :8080")
	flag.Parse()

	if flag.NArg() < 1 {
		panic(fmt.Errorf("positional arguments for files required"))
	}

	f, err := ledger.NewFiles(flag.Args()[0], flag.Args()[1:]...)
	if err != nil {
		panic(err)
	}
	deltas, err := f.Deltas()
	if err != nil {
		panic(err)
	}

	deltas = deltas.Group(ledger.GroupName(*groupName), ledger.GroupDate(*groupDate))

	bpis := make(ledger.BPIs)
	if *bpiPath != "" {
		bpis, err = ledger.NewBPIs(*bpiPath)
		if err != nil {
			panic(err)
		}
	}

	like := ledger.Likes{ledger.LikeName(*likeName)}

	if *httpOutput != "" {
		like = append(like, ledger.LikeBefore(*likeBefore))
		like = append(like, ledger.LikeAfter(*likeAfter))

		foo := func(w http.ResponseWriter, r *http.Request) {
			switch r.URL.Path {
			case "/bal", "/reg":
			case "/ui":
				f, err := os.Open("./index.html")
				if err != nil {
					panic(err)
				}
				defer f.Close()
				io.Copy(w, f)
				return
			default:
				http.NotFound(w, r)
				return
			}

			foolike := make(ledger.Likes, 0)
			for _, v := range r.URL.Query()["likeName"] {
				foolike = append(foolike, ledger.LikeName(v))
			}
			for _, v := range r.URL.Query()["likeAfter"] {
				foolike = append(foolike, ledger.LikeAfter(v))
			}
			for _, v := range r.URL.Query()["likeBefore"] {
				foolike = append(foolike, ledger.LikeBefore(v))
			}
			if len(foolike) == 0 {
				foolike = like
			}

			register := deltas.Like(foolike...).Register()
			predicted := make(ledger.Register)
			bpis := maps.Clone(bpis)

			// MODIFIERS
			if predictionMonths, err := strconv.ParseInt(r.URL.Query().Get("predictionMonths"), 10, 16); err == nil && predictionMonths > 0 {
				window := time.Hour * 24.0 * 365.0 / 12.0 * time.Duration(predictionMonths)
				// TODO whatif
				prediction := make(ana.Prediction, 0)
				for _, spec := range r.URL.Query()["prediction"] {
					idx := strings.Index(spec, "=")
					k := spec[:idx]
					fields := strings.Fields(spec[idx+1:])
					switch k {
					case "interest":
						apy, err := strconv.ParseFloat(fields[2], 64)
						if err != nil {
							panic(err)
						}
						prediction = append(prediction, ana.NewInterestPredictor(fields[0], fields[1], apy))
					case "contributions":
						prediction = append(prediction, ana.NewContributionPredictor(register))
					default:
						panic(k)
					}
				}
				predicted = prediction.Predict(register, window)

				for _, currencyRate := range r.URL.Query()["predictFixedGrowth"] {
					currency := strings.Split(currencyRate, "=")[0]
					rate, err := strconv.ParseFloat(strings.Split(currencyRate, "=")[1], 64)
					if err != nil {
						panic(err)
					}
					bpis, err = ana.BPIsWithFixedGrowthPrediction(bpis, window, currency, rate)
					if err != nil {
						panic(err)
					}
				}
			}

			if r.URL.Query().Get("bpi") != "" {
				register = register.WithBPIs(bpis)
				predicted = predicted.WithBPIs(bpis)
			}
			if zoomStart, err := time.ParseInLocation("2006-01", r.URL.Query().Get("zoomStart"), time.Local); err == nil {
				register = register.Between(zoomStart, time.Now().Add(time.Hour*24*365*100))
				predicted = predicted.Between(zoomStart, time.Now().Add(time.Hour*24*365*100))
			}
			// /MODIFIERS

			toChart := func(cumulative bool, display string, register ledger.Register) Chart {
				nameCurrencyDateValue := map[string]map[ledger.Currency]map[string]float64{}
				for date, balances := range register {
					for name, balance := range balances {
						for currency, value := range balance {
							if _, ok := nameCurrencyDateValue[name]; !ok {
								nameCurrencyDateValue[name] = make(map[ledger.Currency]map[string]float64)
							}
							if _, ok := nameCurrencyDateValue[name][currency]; !ok {
								nameCurrencyDateValue[name][currency] = make(map[string]float64)
							}
							nameCurrencyDateValue[name][currency][date] += value
						}
					}
				}

				chart := NewChart("line")
				if v := display; v != "" {
					chart = NewChart(v)
				}

				dates := register.Dates()
				names := register.Names()
				chart.AddX(dates)

				if cumulative {
					for _, name := range names {
						currencyDateValue := nameCurrencyDateValue[name]
						for currency, dateValue := range currencyDateValue {
							series := make([]int, len(dates))
							for i := range dates {
								var lastValue float64
								for j := range dates[:i+1] {
									if newLastValue, ok := dateValue[dates[j]]; ok {
										lastValue = newLastValue
									}
								}
								series[i] = int(lastValue)
							}
							key := fmt.Sprintf("%s (%s)", name, currency)
							if slices.Min(series) != 0 || slices.Max(series) != 0 {
								chart.AddY(key, series)
							}
						}
					}
				} else {
					for _, name := range names {
						currencyDateValue := nameCurrencyDateValue[name]
						for currency, dateValue := range currencyDateValue {
							series := make([]int, len(dates))
							for i := range dates {
								var prevValue float64
								var lastValue float64
								for j := range dates[:i+1] {
									if newLastValue, ok := dateValue[dates[j]]; ok {
										prevValue = lastValue
										lastValue = newLastValue
									}
								}
								series[i] = int(lastValue - prevValue)
							}
							key := fmt.Sprintf("%s (%s)", name, currency)
							if slices.Min(series) != 0 || slices.Max(series) != 0 {
								chart.AddY(key, series)
							}
						}
					}
				}
				return chart
			}
			primary := toChart(r.URL.Path == "/bal", r.URL.Query().Get("chart"), register)
			if len(predicted) > 0 {
				primary.Overlap(toChart(r.URL.Path == "/bal", "line", predicted))
			}
			if err := primary.Render(w); err != nil {
				panic(err)
			}
		}

		log.Println("listening on", *httpOutput)
		if err := http.ListenAndServe(*httpOutput, http.HandlerFunc(foo)); err != nil {
			panic(err)
		}
	} else {
		if *likeLedger {
			like = append(like, ledger.LikeBefore(*likeBefore))
			like = append(like, ledger.LikeAfter(*likeAfter))
			deltas = deltas.Like(like...)
		} else {
			deltas = deltas.Like(like...)
			like = append(like, ledger.LikeBefore(*likeBefore))
			like = append(like, ledger.LikeAfter(*likeAfter))
		}

		jsonResult := []any{}

		switch *foo {
		case "reg":
			sort.Slice(deltas, func(i, j int) bool {
				return deltas[i].Debug() < deltas[j].Debug()
			})
			register := deltas.Register()
			for i := range deltas {
				if like.All(deltas[i]) {
					if !*jsonOutput {
						fmt.Printf("%s (%+v)\n", deltas[i].Debug(), register[deltas[i].Date][deltas[i].Name].Debug())
					} else {
						jsonResult = append(jsonResult, map[string]any{
							"name":    deltas[i].Name,
							"delta":   deltas[i],
							"balance": register[deltas[i].Date][deltas[i].Name],
						})
					}
				}
			}
		case "bal":
			deltas = deltas.Like(like...)
			for k, v := range deltas.Balances() {
				results := []string{}
				for subk, subv := range v {
					results = append(results, fmt.Sprintf("%s %.2f", subk, subv))
				}
				if len(results) > 0 {
					if !*jsonOutput {
						fmt.Printf("%s\t%s\n", k, strings.Join(results, " + "))
					} else {
						jsonResult = append(jsonResult, map[string]any{
							"name":    k,
							"balance": v,
						})
					}
				}
			}
		default:
			panic(fmt.Errorf("not impl %q", *foo))
		}

		if *jsonOutput {
			json.NewEncoder(os.Stdout).Encode(jsonResult)
		}
	}
}

type Chart interface {
	AddX(interface{})
	AddY(string, []int)
	Render(io.Writer) error
	Overlap(Chart)
}

func NewChart(name string) Chart {
	switch name {
	case "line":
		return NewLine()
	case "bar":
		return NewBar()
	case "stack":
		return NewStack()
	default:
		panic("bad chart name " + name)
	}
}

type Line struct {
	*charts.Line
}

func NewLine() Line {
	return Line{Line: charts.NewLine()}
}

func (line Line) AddX(v interface{}) {
	line.SetXAxis(v)
}

func (line Line) AddY(name string, v []int) {
	y := make([]opts.LineData, len(v))
	for i := range y {
		y[i].Value = v[i]
	}
	line.AddSeries(name, y)
}

func (line Line) Overlap(other Chart) {
	overlapper, ok := other.(charts.Overlaper)
	if !ok {
		panic(fmt.Sprintf("cannot overlap %T", other))
	}
	line.Line.Overlap(overlapper)
}

type Bar struct {
	*charts.Bar
}

func NewBar() Bar {
	return Bar{Bar: charts.NewBar()}
}

func (bar Bar) AddX(v interface{}) {
	bar.SetXAxis(v)
}

func (bar Bar) AddY(name string, v []int) {
	y := make([]opts.BarData, len(v))
	for i := range v {
		y[i].Value = v[i]
	}
	bar.AddSeries(name, y)
}

func (bar Bar) Overlap(other Chart) {
	overlapper, ok := other.(charts.Overlaper)
	if !ok {
		panic(fmt.Sprintf("cannot overlap %T", other))
	}
	bar.Bar.Overlap(overlapper)
}

type Stack struct {
	Bar
}

func NewStack() Stack {
	bar := NewBar()
	bar.SetSeriesOptions(charts.WithBarChartOpts(opts.BarChart{Stack: "x"}))
	return Stack{Bar: bar}
}

func (stack Stack) AddY(name string, v []int) {
	y := make([]opts.BarData, len(v))
	for i := range v {
		y[i].Value = v[i]
	}
	stack.AddSeries(name, y).
		SetSeriesOptions(charts.WithBarChartOpts(opts.BarChart{
			Stack: "stackA",
		}))
}