package main

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

	"github.com/go-echarts/go-echarts/v2/charts"
	"github.com/go-echarts/go-echarts/v2/opts"
	"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) {
			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()

			nameCurrencyDateValue := map[string]map[ledger.Currency]map[string]float64{}
			dates := []string{}
			names := []string{}
			for date, balances := range register {
				dates = append(dates, date)
				if r.URL.Query().Get("bpi") != "" {
					balances = balances.WithBPIs(bpis)
				}
				for name, balance := range balances {
					names = append(names, name)
					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
					}
				}
			}
			slices.Sort(dates)
			slices.Sort(names)

			chart := NewChart("line")
			if v := r.URL.Query().Get("chart"); v != "" {
				chart = NewChart(v)
			}
			chart.AddX(dates)

			switch r.URL.Path {
			default:
				http.NotFound(w, r)
				return
			case "/bal":
				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)
						}
					}
				}
			case "/reg":
				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)
						}
					}
				}
			}
			if err := chart.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
}

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)
}

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)
}

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",
		}))
}