package ledger

import (
	"os"
	"path"
	"path/filepath"
	"testing"
)

func TestFileAdd(t *testing.T) {
	payee := "name:3"
	delta := Delta{
		Date:        "2999-88-77",
		Description: "66",
		Name:        "name:1",
		Value:       2.00,
		Currency:    USD,
	}
	cases := map[string]struct {
		given []byte
		want  string
	}{
		"no file": {
			given: nil,
			want: `2999-88-77 66
  name:1 $2.00
  name:3`,
		},
		"empty file": {
			given: []byte{},
			want: `2999-88-77 66
  name:1 $2.00
  name:3`,
		},
		"happy without trailing whitespace": {
			given: []byte(`
2000-01-02 desc
  name:1 $1.00
  name:2 $-1.00`),
			want: `
2000-01-02 desc
  name:1 $1.00
  name:2 $-1.00
2999-88-77 66
  name:1 $2.00
  name:3`,
		},
		"happy with trailing newline": {
			given: []byte(`
2000-01-02 desc
  name:1 $1.00
  name:2 $-1.00
         `),
			want: `
2000-01-02 desc
  name:1 $1.00
  name:2 $-1.00
2999-88-77 66
  name:1 $2.00
  name:3`,
		},
	}

	for name, d := range cases {
		c := d
		t.Run(name, func(t *testing.T) {
			p := path.Join(t.TempDir(), "input")
			if c.given != nil {
				if err := os.WriteFile(p, []byte(c.given), os.ModePerm); err != nil {
					t.Fatal(err)
				}
			}

			f, err := NewFiles(p)
			if err != nil {
				t.Fatal(err)
			}

			if err := f.Add(payee, delta); err != nil {
				t.Fatal(err)
			}

			if got, err := os.ReadFile(p); err != nil {
				t.Fatal(err)
			} else if string(got) != c.want {
				t.Errorf("wanted\n\t%s, got\n\t%s", c.want, got)
			}
		})
	}
}

func TestFileTestdata(t *testing.T) {
	t.Run("macro.d", func(t *testing.T) {
		paths, err := filepath.Glob("./testdata/macro.d/*")
		if err != nil {
			t.Fatal(err)
		}

		f, err := NewFiles(paths[0], paths[1:]...)
		if err != nil {
			t.Fatal(err)
		}

		deltas, err := f.Deltas()
		if err != nil {
			t.Fatal(err)
		}

		t.Run("deltas", func(t *testing.T) {
			for i := range deltas {
				t.Logf("%+v", deltas[i].Debug())
			}
		})

		t.Run("balances", func(t *testing.T) {
			balances, err := deltas.Balances()
			if err != nil {
				t.Fatal(err)
			}
			for k, v := range balances {
				t.Logf("%s: %+v", k, v)
			}
		})

		t.Run("balances like", func(t *testing.T) {
			balances, err := deltas.Like(LikeName(`^AssetAccount:`)).Balances()
			if err != nil {
				t.Fatal(err)
			}
			for k, v := range balances {
				t.Logf("%s: %+v", k, v)
			}
		})
	})

	t.Run("single files", func(t *testing.T) {
		paths, err := filepath.Glob("./testdata/*.dat")
		if err != nil {
			t.Fatal(err)
		}

		for _, pathd := range paths {
			path := pathd
			t.Run(path, func(t *testing.T) {
				f, err := NewFiles(path)
				if err != nil {
					t.Fatal(err)
				}

				deltas, err := f.Deltas()
				if err != nil {
					t.Fatal(err)
				}

				t.Run("deltas", func(t *testing.T) {
					for i := range deltas {
						t.Logf("%+v", deltas[i].Debug())
					}
				})

				t.Run("balances", func(t *testing.T) {
					balances, err := deltas.Balances()
					if err != nil {
						t.Fatal(err)
					}
					for k, v := range balances {
						t.Logf("%s: %+v", k, v)
					}
				})

				t.Run("balances like", func(t *testing.T) {
					balances, err := deltas.Like(LikeName(`AssetAccount:Cash:Fidelity76`)).Balances()
					if err != nil {
						t.Fatal(err)
					}
					for k, v := range balances {
						t.Logf("%s: %+v", k, v)
					}
				})
			})
		}
	})
}

func TestFileDeltas(t *testing.T) {
	happy := []Delta{
		{
			Date:        "2022-12-12",
			Name:        "AssetAccount:Cash:Fidelity76",
			Value:       -97.92,
			Currency:    USD,
			Description: "Electricity / Power Bill TG2PJ-2PLP5",
		},
		{
			Date:        "2022-12-12",
			Name:        "Withdrawal:0:SharedHome:DominionEnergy",
			Value:       97.92,
			Currency:    USD,
			Description: "Electricity / Power Bill TG2PJ-2PLP5",
		},
		{
			Date:        "2022-12-12",
			Name:        "AssetAccount:Cash:Fidelity76",
			Value:       -1.00,
			Currency:    USD,
			Description: "Test pay chase TG32S-BT2FF",
		},
		{
			Date:        "2022-12-12",
			Name:        "Debts:Credit:ChaseFreedomUltdVisa",
			Value:       1.00,
			Currency:    USD,
			Description: "Test pay chase TG32S-BT2FF",
		},
	}

	cases := map[string][]Delta{
		"empty": nil,
		"one":   happy[:2],
		"happy": happy[:],
	}

	for name, d := range cases {
		want := d
		t.Run(name, func(t *testing.T) {
			f, err := NewFiles("./testdata/" + name + ".dat")
			if err != nil {
				t.Fatal(err)
			}

			deltas, err := f.Deltas()
			if err != nil {
				t.Fatal(err)
			}

			if len(deltas) != len(want) {
				t.Error(len(deltas))
			}
			for i := range want {
				if i >= len(deltas) {
					break
				}
				if want[i] != deltas[i] {
					t.Errorf("[%d] \n\twant=%s, \n\t got=%s", i, want[i].Debug(), deltas[i].Debug())
				}
			}
		})
	}
}