package store_test

import (
	"context"
	"database/sql"
	"testing"

	"github.com/golang-migrate/migrate/v4"
	migratesqlite "github.com/golang-migrate/migrate/v4/database/sqlite"
	"github.com/golang-migrate/migrate/v4/source/iofs"

	"github.com/wangjia/pangolin/server/internal/config"
	"github.com/wangjia/pangolin/server/internal/store"
	"github.com/wangjia/pangolin/server/migrations"
)

// TestApplyCodesLibMigrations verifies the shared codes library's tables are
// created on top of a fully-migrated pangolin sqlite DB (post-000020, the
// legacy tables are renamed away so the lib's `codes` table name is free).
func TestApplyCodesLibMigrations(t *testing.T) {
	ctx := context.Background()
	db, err := store.Open(&config.Config{Driver: "sqlite", DSN: ":memory:"})
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	defer db.Close()
	if err := store.MigrateUp(db, "sqlite"); err != nil {
		t.Fatalf("MigrateUp: %v", err)
	}

	if err := store.ApplyCodesLibMigrations(ctx, db, "sqlite"); err != nil {
		t.Fatalf("ApplyCodesLibMigrations: %v", err)
	}
	// 幂等:重复调用不报错(库自带 codes_schema_migrations 追踪表)。
	if err := store.ApplyCodesLibMigrations(ctx, db, "sqlite"); err != nil {
		t.Fatalf("ApplyCodesLibMigrations 2nd: %v", err)
	}

	for _, tbl := range []string{"codes", "codes_batches", "codes_audit_log", "codes_schema_migrations"} {
		var name string
		if err := db.QueryRow(
			`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, tbl,
		).Scan(&name); err != nil {
			t.Errorf("lib table %q missing: %v", tbl, err)
		}
	}
}

// newSQLiteStepper builds a golang-migrate instance identical to the one
// internal/store.MigrateUp/MigrateDown use internally (same embedded FS,
// same sqlite driver), except it exposes Steps() so the test can land
// exactly on the 000020 boundary instead of only being able to invoke a
// full up-to-latest / down-to-zero round trip like the public API does.
// Mirrors internal/store/migrate.go's newMigrator — kept in the test
// because that constructor is unexported.
func newSQLiteStepper(t *testing.T, database *sql.DB) *migrate.Migrate {
	t.Helper()
	src, err := iofs.New(migrations.SQLiteFS, "sqlite")
	if err != nil {
		t.Fatalf("iofs source: %v", err)
	}
	drv, err := migratesqlite.WithInstance(database, &migratesqlite.Config{})
	if err != nil {
		t.Fatalf("sqlite driver: %v", err)
	}
	m, err := migrate.NewWithInstance("iofs", src, "sqlite", drv)
	if err != nil {
		t.Fatalf("new migrator: %v", err)
	}
	return m
}

// TestCodesLibMigrateRoundTrip exercises the real wired path end-to-end:
// MigrateUp -> ApplyCodesLibMigrations -> step 000020 back down -> assert
// legacy restored/lib gone -> step back up -> ApplyCodesLibMigrations again
// -> finally the full `store.MigrateDown` (== cmd/migrate's "down" command)
// all the way to version 0, which is the exact call the reviewer reported
// as failing hard.
//
// Reproduces the reviewer-found collision: 000020's down does
// legacy_codes -> codes renames, but the codes-lib's own `codes` table
// (created by ApplyCodesLibMigrations, untracked by golang-migrate) is
// still sitting there, so the rename used to fail with "table already
// exists" (sqlite) / "ALTER TABLE ... table already exists" (mysql
// RENAME TABLE semantics). 000020's down script must DROP the lib-owned
// tables before renaming legacy_* back.
func TestCodesLibMigrateRoundTrip(t *testing.T) {
	ctx := context.Background()
	db, err := store.Open(&config.Config{Driver: "sqlite", DSN: ":memory:"})
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	defer db.Close()

	// 1. Up + wire in the codes-lib's own tables (the real cmd/migrate up path).
	if err := store.MigrateUp(db, "sqlite"); err != nil {
		t.Fatalf("MigrateUp: %v", err)
	}
	if err := store.ApplyCodesLibMigrations(ctx, db, "sqlite"); err != nil {
		t.Fatalf("ApplyCodesLibMigrations: %v", err)
	}

	// 2. Step exactly 000020 back down (19 <- 20). This is the precise seam
	// the reviewer's repro hit: the lib's `codes` table collides with the
	// name 000020's down script renames legacy_codes back to.
	m := newSQLiteStepper(t, db)
	// 000021 (pay_purchases/source-enum) now sits on top of 000020 and is
	// unrelated to this collision — step it back down first so we land
	// exactly on the 000020 boundary the test targets.
	if err := m.Steps(-1); err != nil {
		t.Fatalf("step 000021 down: %v", err)
	}
	if err := m.Steps(-1); err != nil {
		t.Fatalf("step 000020 down: %v (this is the reviewer-reported collision — "+
			"000020 down must DROP the codes-lib tables before renaming legacy_* back)", err)
	}

	// 3. Legacy tables restored to their original pangolin names/shape;
	// lib-owned tables gone.
	for _, tbl := range []string{"codes", "code_batches"} {
		var name string
		if err := db.QueryRow(
			`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, tbl,
		).Scan(&name); err != nil {
			t.Errorf("legacy table %q not restored: %v", tbl, err)
		}
	}
	// Original pangolin `codes` shape (plan_id/duration_days), not the
	// codes-lib shape (entitlement_kind/entitlement_payload).
	if _, err := db.Exec(`SELECT plan_id, duration_days, redeemed_by FROM codes LIMIT 0`); err != nil {
		t.Errorf("codes table not restored to pangolin shape: %v", err)
	}
	for _, tbl := range []string{"codes_batches", "codes_audit_log", "codes_schema_migrations"} {
		var name string
		err := db.QueryRow(
			`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, tbl,
		).Scan(&name)
		if err == nil {
			t.Errorf("lib table %q should have been dropped by the 000020 down step, still present", tbl)
		} else if err != sql.ErrNoRows {
			t.Errorf("checking lib table %q gone: %v", tbl, err)
		}
	}

	// 4. Step 000020 back up + reapply the lib migrations: idempotent, must
	// stay green.
	if err := m.Steps(1); err != nil {
		t.Fatalf("step 000020 up (2nd round-trip): %v", err)
	}
	if err := store.ApplyCodesLibMigrations(ctx, db, "sqlite"); err != nil {
		t.Fatalf("ApplyCodesLibMigrations (2nd round-trip): %v", err)
	}

	// 5. Finally, the exact call the reviewer reported as failing hard:
	// `cmd/migrate down` == store.MigrateDown, a full rollback to version 0.
	// Must succeed cleanly (no "table already exists").
	if err := store.MigrateDown(db, "sqlite"); err != nil {
		t.Fatalf("store.MigrateDown (full, == cmd/migrate down): %v", err)
	}
	v, _, err := store.MigrateVersion(db, "sqlite")
	if err != nil {
		t.Fatalf("MigrateVersion after full down: %v", err)
	}
	if v != 0 {
		t.Errorf("version after full MigrateDown = %d, want 0", v)
	}
}