package app

import (
	"context"
	"reflect"
	"slices"
	"strings"
	"testing"
	"time"

	"finance-duck/internal/banking"
	"finance-duck/internal/domain"
)

type historyBank struct {
	bankScenario
	fetched        chan struct{}
	authState      string
	authorizations int
	fromDates      []string
	psuTypes       []string
}

func (b *historyBank) Authorize(_ context.Context, _, _, psuType, state string) (string, error) {
	b.psuTypes = append(b.psuTypes, psuType)
	b.authState = state
	b.authorizations++
	return "https://bank.example/authorize", nil
}

func (b *historyBank) Institutions(context.Context, string) ([]banking.Institution, error) {
	return []banking.Institution{{Name: "N26", Country: "DE"}}, nil
}

func (b *historyBank) Transactions(_ context.Context, account domain.Account, from, to string, _ bool) ([]domain.Facts, error) {
	b.fromDates = append(b.fromDates, from)
	var rows []domain.Facts
	for _, days := range []int{400, 300, 1} {
		date := time.Now().UTC().AddDate(0, 0, -days).Format("2006-01-02")
		if date >= from && date <= to {
			rows = append(rows, domain.Facts{Source: "enablebanking", AccountID: account.ID, BookingDate: date, Amount: "-10.00", Currency: "EUR", RawDescription: "Card payment", ExternalID: "entry_" + date})
		}
	}
	if b.fetched != nil {
		select {
		case b.fetched <- struct{}{}:
		default:
		}
	}
	return rows, nil
}
func TestNewAccountImportsHistoryIndependentOfExistingSyncCursor(t *testing.T) {
	a, s := testApp(t)
	old := s.Data.Accounts[0]
	old.ExternalAccountID = "old_uid"
	fresh := domain.Account{ID: "ing", DisplayName: "ING", Institution: "ING", Currency: "EUR", ExternalAccountID: "new_uid", Active: true}
	s, err := a.Mutate(context.Background(), s.Revision, func(d *domain.Dataset) error { d.Accounts = []domain.Account{old, fresh}; return nil })
	if err != nil {
		t.Fatal(err)
	}
	session := banking.Session{ID: "consent", ValidUntil: time.Now().Add(24 * time.Hour).Format(time.RFC3339), Accounts: s.Data.Accounts}
	b := &historyBank{bankScenario: bankScenario{session: session}}
	a.bank = b
	a.ops.Sessions = []banking.Session{session}
	a.ops.LastSync = time.Now().UTC().Add(-24 * time.Hour).Format(time.RFC3339)
	a.ops.AccountSync[old.ID] = a.ops.LastSync
	if err := a.saveOps(); err != nil {
		t.Fatal(err)
	}
	a = reopenBankingApp(t, a)
	a.bank = b
	after, err := a.Sync(context.Background())
	if err != nil {
		t.Fatal(err)
	}
	counts := map[string]int{}
	for _, tx := range after.Data.Transactions {
		counts[tx.Facts.AccountID]++
	}
	if counts[old.ID] != 1 || counts[fresh.ID] != 2 {
		t.Fatalf("new account history skipped: %v", counts)
	}
}

func TestAuthorizedHistorySurvivesReopenAndRespectsIncrementalCursor(t *testing.T) {
	a, s := testApp(t)
	ctx := context.Background()
	account := s.Data.Accounts[0]
	account.ExternalAccountID = "history_uid"
	b := &historyBank{bankScenario: bankScenario{session: banking.Session{ID: "history_session", ValidUntil: time.Now().Add(24 * time.Hour).Format(time.RFC3339), Accounts: []domain.Account{account}}}}
	a.bank = b
	for _, months := range []int{-1, 0, 121} {
		if _, err := a.Authorize(ctx, "N26", "DE", banking.PSUPersonal, months); err == nil {
			t.Fatalf("accepted invalid history choice %d", months)
		}
	}
	if b.authorizations != 0 {
		t.Fatal("invalid history choice reached the bank")
	}
	if _, err := a.Authorize(ctx, "N26", "DE", banking.PSUPersonal, 24); err != nil {
		t.Fatal(err)
	}
	if _, err := a.Callback(ctx, "one_time_code", b.authState); err != nil {
		t.Fatal(err)
	}
	a = reopenBankingApp(t, a)
	a.bank = b
	s, err := a.Snapshot(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(s.Connections) != 1 || s.Connections[0].HistoryMonths != 24 {
		t.Fatalf("saved history choice unavailable after restart: %+v", s.Connections)
	}
	before := time.Now().UTC().AddDate(0, -24, 0).Format("2006-01-02")
	first, err := a.Sync(ctx)
	if err != nil {
		t.Fatal(err)
	}
	after := time.Now().UTC().AddDate(0, -24, 0).Format("2006-01-02")
	if len(first.Data.Transactions) != 3 {
		t.Fatalf("selected history did not import older transactions: %+v", first.Data.Transactions)
	}
	if len(b.fromDates) != 1 || (b.fromDates[0] != before && b.fromDates[0] != after) {
		t.Fatalf("initial import did not use 24 calendar months: %v", b.fromDates)
	}
	cursor, err := time.Parse(time.RFC3339, first.Status.LastSync)
	if err != nil {
		t.Fatal(err)
	}
	a = reopenBankingApp(t, a)
	a.bank = b
	again, err := a.Sync(ctx)
	if err != nil {
		t.Fatal(err)
	}
	wantFrom := cursor.AddDate(0, 0, -14).Format("2006-01-02")
	if len(b.fromDates) != 2 || b.fromDates[1] != wantFrom {
		t.Fatalf("incremental import ignored saved cursor: %v, want %s", b.fromDates, wantFrom)
	}
	if len(again.Data.Transactions) != 3 || again.Connections[0].HistoryMonths != 24 {
		t.Fatal("incremental import duplicated history or lost the selected window")
	}
}
func TestExpiredConsentIsVisibleBeforeNextScheduledSync(t *testing.T) {
	a, s := testApp(t)
	account := s.Data.Accounts[0]
	account.ExternalAccountID = "uid"
	_, err := a.Mutate(context.Background(), s.Revision, func(d *domain.Dataset) error { return SaveAccount(d, account) })
	if err != nil {
		t.Fatal(err)
	}
	a.ops.Sessions = []banking.Session{{ID: "expired", ValidUntil: time.Now().Add(-time.Hour).Format(time.RFC3339), Accounts: []domain.Account{account}}}
	a.ops.Consents["expired"] = Consent{Institution: "ING", Country: "DE"}
	after, err := a.Snapshot(context.Background())
	if err != nil {
		t.Fatal(err)
	}
	if len(after.Connections) != 1 || after.Connections[0].Status != "reconnect_required" || after.Connections[0].Institution != "ING" {
		t.Fatalf("missing bank reconnect status: %+v", after.Connections)
	}
	if after.Connections[0].HistoryMonths != 12 {
		t.Fatal("legacy consent did not retain the default reconnect history")
	}
}
func TestRenewedConsentWakesSchedulerAndAutomaticallyImports(t *testing.T) {
	a, s := testApp(t)
	account := s.Data.Accounts[0]
	account.ExternalAccountID = "renewed_uid"
	b := &historyBank{bankScenario: bankScenario{session: banking.Session{ID: "renewed_session", ValidUntil: time.Now().Add(24 * time.Hour).Format(time.RFC3339), Accounts: []domain.Account{account}}}, fetched: make(chan struct{}, 1)}
	a.bank = b
	a.ops.LastSync = time.Now().UTC().Format(time.RFC3339)
	a.authStates["state"] = authorization{Expires: time.Now().Add(time.Minute), Institution: "N26", Country: "DE", HistoryMonths: 12}
	ctx, cancel := context.WithCancel(context.Background())
	done := make(chan struct{})
	go func() { defer close(done); a.RunScheduler(ctx) }()
	defer func() { cancel(); <-done }()
	if _, err := a.Callback(context.Background(), "one_time_code", "state"); err != nil {
		t.Fatal(err)
	}
	select {
	case <-b.fetched:
	case <-time.After(10 * time.Second):
		t.Fatal("renewal did not wake automatic synchronization")
	}
	after, err := a.Snapshot(context.Background())
	if err != nil {
		t.Fatal(err)
	}
	if len(after.Data.Transactions) != 2 || len(after.Sessions) != 1 || after.Connections[0].Status != "connected" {
		t.Fatalf("renewed consent not usable: %+v", after)
	}
}

type recoveryBank struct{ historyBank }

func (b *recoveryBank) Status(ctx context.Context, id string) (banking.SessionStatus, error) {
	if id != b.session.ID {
		return banking.SessionStatus{}, banking.ErrReconnect
	}
	return b.historyBank.Status(ctx, id)
}

func TestInterruptedRenewalDiscardsSupersededConsentDuringRecovery(t *testing.T) {
	a, s := testApp(t)
	old := s.Data.Accounts[0]
	old.ExternalAccountID = "old_uid"
	renewed := old
	renewed.ExternalAccountID = "new_uid"
	session := banking.Session{ID: "new_session", ValidUntil: time.Now().Add(time.Hour).Format(time.RFC3339), Accounts: []domain.Account{renewed}}
	a.bank = &recoveryBank{historyBank{bankScenario: bankScenario{session: session}}}
	a.ops.Sessions = []banking.Session{{ID: "old_session", Accounts: []domain.Account{old}}, session}
	after, err := a.Sync(context.Background())
	if err != nil {
		t.Fatal(err)
	}
	if after.Status.SyncError != "" || len(after.Sessions) != 1 || after.Sessions[0].ID != "new_session" {
		t.Fatalf("superseded consent survived recovery: %+v", after)
	}
	if len(after.Data.Transactions) != 2 || after.Connections[0].Status != "connected" {
		t.Fatal("recovered replacement did not resume imports")
	}
}

// A removed bank account must stay removed. Session recovery reconstructs
// bindings for interrupted connects, so a stale binding silently resurrects
// the account on the next connect or sync.
func TestDeletedBankAccountIsNotResurrectedByLaterConnectOrSync(t *testing.T) {
	a, s := testApp(t)
	ctx := context.Background()
	kept := s.Data.Accounts[0]
	kept.ExternalAccountID = "kept_uid"
	removed := domain.Account{ID: "removed_acct", DisplayName: "Mwst", Institution: "N26", Currency: "EUR", ExternalAccountID: "removed_uid", Active: true}
	s, err := a.Mutate(ctx, s.Revision, func(d *domain.Dataset) error {
		d.Accounts = []domain.Account{kept, removed}
		return nil
	})
	if err != nil {
		t.Fatal(err)
	}
	session := banking.Session{ID: "n26_session", ValidUntil: time.Now().Add(24 * time.Hour).Format(time.RFC3339), Accounts: []domain.Account{kept, removed}}
	b := &historyBank{bankScenario: bankScenario{session: session}}
	a.bank = b
	a.ops.Sessions = []banking.Session{session}
	a.ops.Consents[session.ID] = Consent{Institution: "N26", Country: "DE", HistoryMonths: 12}
	a.ops.AccountSync[removed.ID] = time.Now().UTC().Format(time.RFC3339)
	if err := a.saveOps(); err != nil {
		t.Fatal(err)
	}
	s, err = a.ManageRegistry(ctx, s.Revision, "account", "delete", removed.ID, "")
	if err != nil {
		t.Fatal(err)
	}
	if slices.ContainsFunc(s.Data.Accounts, func(v domain.Account) bool { return v.ID == removed.ID }) {
		t.Fatal("account deletion did not remove the account")
	}
	if _, tracked := a.ops.AccountSync[removed.ID]; tracked {
		t.Fatal("deleted account kept its sync cursor")
	}
	// A later connect for a different bank triggers binding recovery.
	other := domain.Account{ID: "ing_acct", DisplayName: "ING Giro", Institution: "ING", Currency: "EUR", ExternalAccountID: "ing_uid", Active: true}
	b.session = banking.Session{ID: "ing_session", ValidUntil: time.Now().Add(24 * time.Hour).Format(time.RFC3339), Accounts: []domain.Account{other}}
	if _, err := a.Authorize(ctx, "ING", "DE", banking.PSUPersonal, 12); err != nil {
		t.Fatal(err)
	}
	if _, err := a.Callback(ctx, "one_time_code", b.authState); err != nil {
		t.Fatal(err)
	}
	a = reopenBankingApp(t, a)
	a.bank = b
	after, err := a.Sync(ctx)
	if err != nil {
		t.Fatal(err)
	}
	names := map[string]bool{}
	for _, account := range after.Data.Accounts {
		names[account.ID] = true
	}
	if names[removed.ID] {
		t.Fatalf("deleted bank account reappeared: %+v", after.Data.Accounts)
	}
	if !names[kept.ID] || !names[other.ID] {
		t.Fatalf("connecting another bank lost existing accounts: %+v", after.Data.Accounts)
	}
	for _, connection := range after.Connections {
		if connection.AccountID == removed.ID {
			t.Fatal("deleted account still reported as connected")
		}
	}
}

// A consent that shares no accounts cannot sync and its session is reaped by
// recovery, so the user must be told instead of being silently redirected.
func TestConnectWithoutSharedAccountsFailsVisibly(t *testing.T) {
	a, _ := testApp(t)
	ctx := context.Background()
	b := &historyBank{bankScenario: bankScenario{session: banking.Session{ID: "empty_session", ValidUntil: time.Now().Add(24 * time.Hour).Format(time.RFC3339)}}}
	a.bank = b
	if _, err := a.Authorize(ctx, "Kontist", "DE", banking.PSUBusiness, 12); err != nil {
		t.Fatal(err)
	}
	_, err := a.Callback(ctx, "one_time_code", b.authState)
	if err == nil || !strings.Contains(err.Error(), "no accounts") {
		t.Fatalf("empty consent reported success: %v", err)
	}
	after, e := a.Snapshot(ctx)
	if e != nil {
		t.Fatal(e)
	}
	if len(after.Sessions) != 0 {
		t.Fatalf("unusable consent was stored: %+v", after.Sessions)
	}
	for _, connection := range after.Connections {
		if connection.Status != "local" {
			t.Fatalf("unusable consent produced a bank connection: %+v", connection)
		}
	}
}

// A business consent must stay business: reconnecting a business account with
// the personal flow authorizes a consent that shares no accounts.
func TestSavedAccountHolderTypeSurvivesRestartForReconnect(t *testing.T) {
	a, s := testApp(t)
	ctx := context.Background()
	account := s.Data.Accounts[0]
	account.ExternalAccountID = "kontist_uid"
	b := &historyBank{bankScenario: bankScenario{session: banking.Session{ID: "kontist_session", ValidUntil: time.Now().Add(24 * time.Hour).Format(time.RFC3339), Accounts: []domain.Account{account}}}}
	a.bank = b
	if _, err := a.Authorize(ctx, "Kontist", "DE", banking.PSUBusiness, 12); err != nil {
		t.Fatal(err)
	}
	if _, err := a.Callback(ctx, "one_time_code", b.authState); err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(b.psuTypes, []string{banking.PSUBusiness}) {
		t.Fatalf("chosen account type did not reach the provider: %q", b.psuTypes)
	}
	a = reopenBankingApp(t, a)
	a.bank = b
	after, err := a.Snapshot(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(after.Connections) != 1 || after.Connections[0].PSUType != banking.PSUBusiness {
		t.Fatalf("account type unavailable for reconnecting: %+v", after.Connections)
	}
	for _, invalid := range []string{"corporate", "Personal"} {
		if _, err := a.Authorize(ctx, "Kontist", "DE", invalid, 12); err == nil {
			t.Fatalf("accepted undocumented account type %q", invalid)
		}
	}
	// Legacy consents predate the choice and stay on the personal flow.
	meta := a.ops.Consents["kontist_session"]
	meta.PSUType = ""
	a.ops.Consents["kontist_session"] = meta
	legacy, err := a.Snapshot(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if legacy.Connections[0].PSUType != banking.PSUPersonal {
		t.Fatalf("legacy consent lost its personal default: %+v", legacy.Connections)
	}
}