package repository

import (
	"database/sql"
	"fmt"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/go-sql-driver/mysql"
	"github.com/wmms/wmms/pkg/database"
)

// Each test creates its own disposable schema on the explicitly configured server.
func isolationDB(t *testing.T, legacy bool) *sql.DB {
	t.Helper()
	dsn := os.Getenv("TEST_DB_DSN")
	if dsn == "" {
		t.Skip("real MySQL integration requires TEST_DB_DSN")
	}
	cfg, err := mysql.ParseDSN(dsn)
	if err != nil {
		t.Fatal(err)
	}
	if !strings.HasPrefix(cfg.DBName, "company_isolation_test") {
		t.Fatal("TEST_DB_DSN must name a company_isolation_test schema")
	}
	cfg.DBName = ""
	cfg.MultiStatements = true
	cfg.ParseTime = true
	admin, err := sql.Open("mysql", cfg.FormatDSN())
	if err != nil {
		t.Fatal(err)
	}
	name := fmt.Sprintf("company_isolation_test_%d", time.Now().UnixNano())
	if _, err = admin.Exec("CREATE DATABASE `" + name + "` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci"); err != nil {
		admin.Close()
		t.Fatal(err)
	}
	cfg.DBName = name
	db, err := sql.Open("mysql", cfg.FormatDSN())
	if err != nil {
		t.Fatal(err)
	}
	original := database.DB
	database.DB = db
	t.Cleanup(func() { database.DB = original; db.Close(); admin.Exec("DROP DATABASE `" + name + "`"); admin.Close() })
	path := filepath.Join("..", "..", "scripts", "init.sql")
	if legacy {
		path = filepath.Join("testdata", "company-isolation-legacy.sql")
	}
	content, err := os.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}
	var lines []string
	for _, line := range strings.Split(strings.TrimPrefix(string(content), "\ufeff"), "\n") {
		if strings.HasPrefix(line, "CREATE DATABASE") || strings.HasPrefix(line, "USE ") {
			continue
		}
		lines = append(lines, line)
	}
	if _, err = db.Exec(strings.Join(lines, "\n")); err != nil {
		t.Fatalf("initialize %s: %v", path, err)
	}
	return db
}

func mustSQL(t *testing.T, db *sql.DB, query string, args ...interface{}) {
	t.Helper()
	if _, err := db.Exec(query, args...); err != nil {
		t.Fatalf("fixture SQL: %v\n%s", err, query)
	}
}

// DELIMITER is a mysql-client directive, not server SQL. Execute the same file's
// statements with its declared delimiter, including the full stored procedure.
func runIsolationSQL(db *sql.DB, path string) error {
	content, err := os.ReadFile(path)
	if err != nil {
		return err
	}
	delimiter := ";"
	var statement strings.Builder
	for _, line := range strings.Split(string(content), "\n") {
		trimmed := strings.TrimSpace(line)
		if strings.HasPrefix(trimmed, "DELIMITER ") {
			delimiter = strings.TrimSpace(strings.TrimPrefix(trimmed, "DELIMITER "))
			continue
		}
		if strings.HasPrefix(trimmed, "--") || trimmed == "" {
			continue
		}
		statement.WriteString(line)
		statement.WriteByte('\n')
		accumulated := strings.TrimSpace(statement.String())
		if strings.HasSuffix(accumulated, delimiter) {
			accumulated = strings.TrimSuffix(accumulated, delimiter)
			if _, err = db.Exec(accumulated); err != nil {
				return err
			}
			statement.Reset()
		}
	}
	if strings.TrimSpace(statement.String()) != "" {
		return fmt.Errorf("unterminated SQL in %s", path)
	}
	return nil
}

func upgradeIsolation(db *sql.DB) error {
	return runIsolationSQL(db, filepath.Join("..", "..", "scripts", "upgrades", "2026-10-08-company-master-data-isolation.sql"))
}

func seedIsolationHistory(t *testing.T, db *sql.DB) {
	mustSQL(t, db, `INSERT INTO organizations(id,code,name) VALUES (1,'ONE','One'),(2,'TWO','Two');
 INSERT INTO users(id,username,password) VALUES (1,'ordinary','x'),(2,'admin','x');
 INSERT INTO roles(id,code,name) VALUES(1,'super_admin','Admin'); INSERT INTO user_roles VALUES(2,1,NOW());
 INSERT INTO user_organizations(user_id,organization_id,is_default) VALUES(1,2,1);
 INSERT INTO material_categories(id,organization_id,code,name) VALUES(1,1,'C','C'),(2,2,'C','C');
 INSERT INTO units(id,organization_id,code,name) VALUES(1,1,'U','U'),(2,2,'U','U');
 INSERT INTO materials(id,organization_id,material_code,name,category_id,base_unit_id) VALUES(1,1,'M','M',1,1),(2,2,'M','M',2,2);
 INSERT INTO warehouses(id,organization_id,code,name) VALUES(1,1,'W','W'),(2,2,'W','W');
 INSERT INTO warehouse_locations(id,warehouse_id,code,name) VALUES(1,1,'L','L'),(2,2,'L','L');
 INSERT INTO inventory_balances(organization_id,warehouse_id,location_id,material_id,on_hand,reserved,locked,in_transit) VALUES(2,2,2,2,8,1,2,3);
 INSERT INTO inbound_orders(id,organization_id,warehouse_id,location_id,inbound_date,handler) VALUES(1,2,2,2,NOW(),'H');
 INSERT INTO inbound_items(inbound_order_id,material_id,quantity) VALUES(1,2,10);
 INSERT INTO outbound_orders(id,organization_id,warehouse_id,location_id,outbound_date,handler,receiver) VALUES(1,2,2,2,NOW(),'H','R');
 INSERT INTO outbound_items(outbound_order_id,material_id,quantity) VALUES(1,2,2);
 INSERT INTO material_applications(id,user_id) VALUES(1,1);
 INSERT INTO application_items(application_id,material_id,quantity) VALUES(1,2,2);
 INSERT INTO stock_logs(material_id,type,quantity,related_order_type,related_order_id) VALUES(2,'in',10,'inbound',1),(2,'out',2,'outbound',1);`)
}

func assertIsolationConstraints(t *testing.T, db *sql.DB) {
	t.Helper()
	mustSQL(t, db, `INSERT INTO organizations(id,code,name) VALUES(10,'TEN','Ten'),(11,'ELEVEN','Eleven'),(12,'TWELVE','Twelve');
 INSERT INTO users(id,username,password) VALUES(10,'constraint','x');
 INSERT INTO user_organizations(user_id,organization_id,is_default) VALUES(10,10,1);`)
	if _, err := db.Exec(`INSERT INTO user_organizations(user_id,organization_id,is_default) VALUES(10,11,1)`); err == nil {
		t.Fatal("second default organization was accepted")
	}
	mustSQL(t, db, `INSERT INTO user_organizations(user_id,organization_id,is_default) VALUES(10,11,0),(10,12,0)`)
	mustSQL(t, db, `INSERT INTO users(id,username,password) VALUES(11,'default-race','x')`)
	var defaultWG sync.WaitGroup
	defaultStart := make(chan struct{})
	defaultResults := make(chan error, 2)
	for _, organizationID := range []int64{10, 11} {
		defaultWG.Add(1)
		go func(id int64) {
			defer defaultWG.Done()
			<-defaultStart
			_, err := db.Exec(`INSERT INTO user_organizations(user_id,organization_id,is_default) VALUES(11,?,1)`, id)
			defaultResults <- err
		}(organizationID)
	}
	close(defaultStart)
	defaultWG.Wait()
	close(defaultResults)
	defaultSuccesses := 0
	for err := range defaultResults {
		if err == nil {
			defaultSuccesses++
		} else if me, ok := err.(*mysql.MySQLError); !ok || me.Number != 1062 {
			t.Fatalf("unexpected default race error: %v", err)
		}
	}
	if defaultSuccesses != 1 {
		t.Fatalf("concurrent default successes=%d, want 1", defaultSuccesses)
	}
	mustSQL(t, db, `INSERT INTO warehouses(id,organization_id,code,name,status) VALUES(10,10,'W','W','inactive'),(11,11,'W','W','active');
 INSERT INTO warehouse_locations(id,warehouse_id,code,name,status) VALUES(10,10,'L','L','inactive'),(11,11,'L','L','active');`)
	for _, query := range []string{`INSERT INTO warehouses(organization_id,code,name) VALUES(10,'SECOND','Second')`, `INSERT INTO warehouse_locations(warehouse_id,code,name) VALUES(10,'SECOND','Second')`} {
		if _, err := db.Exec(query); err == nil {
			t.Fatalf("unique dimension bypassed: %s", query)
		}
	}
	// Race two independent connections; only one creation may commit.
	for _, query := range []string{`INSERT INTO warehouses(organization_id,code,name) VALUES(12,?,?)`, `INSERT INTO warehouse_locations(warehouse_id,code,name) SELECT id,?,? FROM warehouses WHERE organization_id=12`} {
		var wg sync.WaitGroup
		start := make(chan struct{})
		results := make(chan error, 2)
		for i := 0; i < 2; i++ {
			wg.Add(1)
			go func(i int) {
				defer wg.Done()
				<-start
				_, err := db.Exec(query, fmt.Sprint(i), fmt.Sprint(i))
				results <- err
			}(i)
		}
		close(start)
		wg.Wait()
		close(results)
		successes := 0
		for err := range results {
			if err == nil {
				successes++
			} else if me, ok := err.(*mysql.MySQLError); !ok || me.Number != 1062 {
				t.Fatalf("unexpected race failure: %v", err)
			}
		}
		if successes != 1 {
			t.Fatalf("concurrent creation successes=%d, want 1", successes)
		}
	}
}

func TestCompanyIsolationFreshInit(t *testing.T) {
	db := isolationDB(t, false)
	assertIsolationConstraints(t, db)
	assertIsolationRequiredDimensions(t, db)
	// Explicit dimensions are mandatory; absence must fail rather than company 1.
	for _, query := range []string{`INSERT INTO inbound_orders(inbound_date,handler) VALUES(NOW(),'H')`, `INSERT INTO outbound_orders(outbound_date,handler,receiver) VALUES(NOW(),'H','R')`, `INSERT INTO material_applications(user_id) VALUES(10)`, `INSERT INTO stock_logs(material_id,type,quantity,related_order_type,related_order_id) VALUES(1,'in',1,'inbound',1)`} {
		_, err := db.Exec(query)
		if me, ok := err.(*mysql.MySQLError); !ok || me.Number != 1364 {
			t.Fatalf("missing dimensions must fail with no default (1364), got %v: %s", err, query)
		}
	}
	if err := upgradeIsolation(db); err == nil {
		t.Fatal("fresh schema must already record the migration version")
	}
}

func assertIsolationRequiredDimensions(t *testing.T, db *sql.DB) {
	t.Helper()
	for _, tc := range []struct {
		table   string
		columns []string
	}{
		{"inbound_orders", []string{"organization_id", "warehouse_id", "location_id"}},
		{"outbound_orders", []string{"organization_id", "warehouse_id", "location_id"}},
		{"stock_logs", []string{"organization_id", "warehouse_id", "location_id"}},
		{"material_applications", []string{"organization_id"}},
	} {
		for _, column := range tc.columns {
			var nullable string
			var defaultValue sql.NullString
			if err := db.QueryRow(`SELECT is_nullable,column_default FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name=? AND column_name=?`, tc.table, column).Scan(&nullable, &defaultValue); err != nil {
				t.Fatal(err)
			}
			if nullable != "NO" || defaultValue.Valid {
				t.Fatalf("%s.%s nullable=%s default=%v", tc.table, column, nullable, defaultValue)
			}
		}
	}
}

// Schema parity covers real column types/null/default/generated expressions,
// index column order/uniqueness, and foreign keys, ignoring names/order of FKs.
func isolationSchema(t *testing.T, db *sql.DB) []string {
	t.Helper()
	var signature []string
	for _, query := range []string{
		`SELECT CONCAT('column:',table_name,':',column_name,':',column_type,':',is_nullable,':',COALESCE(column_default,'<null>'),':',extra,':',generation_expression) FROM information_schema.columns WHERE table_schema=DATABASE() ORDER BY table_name,column_name`,
		`SELECT CONCAT('index:',table_name,':',index_name,':',non_unique,':',GROUP_CONCAT(column_name ORDER BY seq_in_index)) FROM information_schema.statistics WHERE table_schema=DATABASE() GROUP BY table_name,index_name,non_unique ORDER BY table_name,index_name`,
		`SELECT CONCAT('fk:',table_name,':',column_name,':',referenced_table_name,':',referenced_column_name) FROM information_schema.key_column_usage WHERE table_schema=DATABASE() AND referenced_table_name IS NOT NULL ORDER BY table_name,column_name`,
	} {
		rows, err := db.Query(query)
		if err != nil {
			t.Fatal(err)
		}
		for rows.Next() {
			var value string
			if err := rows.Scan(&value); err != nil {
				rows.Close()
				t.Fatal(err)
			}
			signature = append(signature, value)
		}
		if err := rows.Err(); err != nil {
			t.Fatal(err)
		}
		rows.Close()
	}
	return signature
}

func TestCompanyIsolationFreshAndUpgradedSchemaAgree(t *testing.T) {
	fresh := isolationDB(t, false)
	want := isolationSchema(t, fresh)
	upgraded := isolationDB(t, true)
	seedIsolationHistory(t, upgraded)
	if err := upgradeIsolation(upgraded); err != nil {
		t.Fatal(err)
	}
	got := isolationSchema(t, upgraded)
	if !reflect.DeepEqual(got, want) {
		wanted := map[string]bool{}
		actual := map[string]bool{}
		for _, v := range want {
			wanted[v] = true
		}
		for _, v := range got {
			actual[v] = true
		}
		for _, v := range got {
			if !wanted[v] {
				t.Logf("upgrade only: %s", v)
			}
		}
		for _, v := range want {
			if !actual[v] {
				t.Logf("fresh only: %s", v)
			}
		}
		t.Fatal("fresh and upgraded schema differ")
	}
}

func TestCompanyIsolationApplicationLogBackfill(t *testing.T) {
	db := isolationDB(t, true)
	seedIsolationHistory(t, db)
	mustSQL(t, db, `UPDATE material_applications SET status='approved' WHERE id=1; UPDATE stock_logs SET related_order_type='application' WHERE id=2`)
	if err := upgradeIsolation(db); err != nil {
		t.Fatal(err)
	}
	assertIsolationRequiredDimensions(t, db)
	var org, warehouse, location int64
	if err := db.QueryRow(`SELECT organization_id,warehouse_id,location_id FROM stock_logs WHERE id=2`).Scan(&org, &warehouse, &location); err != nil {
		t.Fatal(err)
	}
	if org != 2 || warehouse != 2 || location != 2 {
		t.Fatalf("application log=%d/%d/%d, want 2/2/2", org, warehouse, location)
	}
	// After upgrading, checks must also reject stored dimensions that disagree
	// with the verified source document, even if each standalone FK is valid.
	mustSQL(t, db, `UPDATE stock_logs SET organization_id=1 WHERE id=2`)
	if err := runIsolationSQL(db, filepath.Join("..", "..", "scripts", "checks", "company-master-data-integrity.sql")); err != nil {
		t.Fatal(err)
	}
	var anomalies int
	if err := db.QueryRow(`SELECT COUNT(*) FROM tmp_company_integrity_anomalies WHERE issue='stored_stock_log_dimensions' AND entity_id=2`).Scan(&anomalies); err != nil || anomalies != 1 {
		t.Fatalf("stored dimension anomaly=%d err=%v", anomalies, err)
	}
	mustSQL(t, db, `UPDATE material_applications SET organization_id=1 WHERE id=1`)
	if err := runIsolationSQL(db, filepath.Join("..", "..", "scripts", "checks", "company-master-data-integrity.sql")); err != nil {
		t.Fatal(err)
	}
	if err := db.QueryRow(`SELECT COUNT(*) FROM tmp_company_integrity_anomalies WHERE issue='stored_application_dimensions' AND entity_id=1`).Scan(&anomalies); err != nil || anomalies != 1 {
		t.Fatalf("stored application anomaly=%d err=%v", anomalies, err)
	}
}

func TestCompanyIsolationApplicationLogsRejectUnverifiedSources(t *testing.T) {
	for _, tc := range []struct{ name, query string }{
		{"unapproved", `UPDATE stock_logs SET related_order_type='application' WHERE id=2`},
		{"quantity mismatch", `UPDATE material_applications SET status='approved' WHERE id=1; UPDATE stock_logs SET related_order_type='application',quantity=999 WHERE id=2`},
		{"missing inventory", `UPDATE material_applications SET status='approved' WHERE id=1; UPDATE stock_logs SET related_order_type='application' WHERE id=2; DELETE FROM inventory_balances`},
	} {
		t.Run(tc.name, func(t *testing.T) {
			db := isolationDB(t, true)
			seedIsolationHistory(t, db)
			mustSQL(t, db, tc.query)
			err := upgradeIsolation(db)
			if err == nil || !strings.Contains(err.Error(), "integrity anomalies") {
				t.Fatalf("unverified source accepted: %v", err)
			}
		})
	}
}

func TestCompanyIsolationLegacyUpgrade(t *testing.T) {
	db := isolationDB(t, true)
	seedIsolationHistory(t, db)
	if err := upgradeIsolation(db); err != nil {
		t.Fatal(err)
	}
	var org, warehouse, location int64
	if err := db.QueryRow(`SELECT organization_id,warehouse_id,location_id FROM stock_logs WHERE id=1`).Scan(&org, &warehouse, &location); err != nil {
		t.Fatal(err)
	}
	if org != 2 || warehouse != 2 || location != 2 {
		t.Fatalf("log dimensions=%d/%d/%d, want 2/2/2", org, warehouse, location)
	}
	if err := db.QueryRow(`SELECT organization_id FROM material_applications WHERE id=1`).Scan(&org); err != nil || org != 2 {
		t.Fatalf("application org=%d err=%v", org, err)
	}
	var count int
	if err := db.QueryRow(`SELECT COUNT(*) FROM schema_migration_reconciliations WHERE version='2026-10-08-company-master-data-isolation' AND phase IN ('before','after')`).Scan(&count); err != nil || count != 4 {
		t.Fatalf("snapshots=%d err=%v", count, err)
	}
	var onHand string
	if err := db.QueryRow(`SELECT on_hand FROM schema_migration_reconciliations WHERE organization_id=2 AND phase='after'`).Scan(&onHand); err != nil || onHand != "8.000000" {
		t.Fatalf("stock reconciliation=%s err=%v", onHand, err)
	}
	for _, phase := range []string{"before", "after"} {
		var reserved, locked, inTransit string
		var inbound, outbound, applications, logs int64
		if err := db.QueryRow(`SELECT reserved,locked,in_transit,inbound_count,outbound_count,application_count,stock_log_count FROM schema_migration_reconciliations WHERE organization_id=2 AND phase=?`, phase).Scan(&reserved, &locked, &inTransit, &inbound, &outbound, &applications, &logs); err != nil {
			t.Fatal(err)
		}
		if reserved != "1.000000" || locked != "2.000000" || inTransit != "3.000000" || inbound != 1 || outbound != 1 || applications != 1 || logs != 2 {
			t.Fatalf("%s reconciliation=%s/%s/%s/%d/%d/%d/%d", phase, reserved, locked, inTransit, inbound, outbound, applications, logs)
		}
	}
	var status, version string
	if err := db.QueryRow(`SELECT status,JSON_UNQUOTE(JSON_EXTRACT(details,'$.version')) FROM schema_migrations WHERE version='2026-10-08-company-master-data-isolation'`).Scan(&status, &version); err != nil || status != "completed" || version != "2026-10-08-company-master-data-isolation" {
		t.Fatalf("version record=%s/%s err=%v", status, version, err)
	}
	if err := upgradeIsolation(db); err == nil {
		t.Fatal("migration rerun accepted")
	}
	for _, state := range []string{"running", "failed"} {
		mustSQL(t, db, `UPDATE schema_migrations SET status=? WHERE version='2026-10-08-company-master-data-isolation'`, state)
		if err := upgradeIsolation(db); err == nil || !strings.Contains(err.Error(), "version already recorded") {
			t.Fatalf("%s version was rerun: %v", state, err)
		}
	}
	assertIsolationConstraints(t, db)
}

func TestCompanyIsolationInvalidHistoryBlocksUpgrade(t *testing.T) {
	cases := []struct{ name, query string }{
		{"duplicate defaults", `INSERT INTO user_organizations(user_id,organization_id,is_default) VALUES(1,1,1)`},
		{"multiple warehouses", `INSERT INTO warehouses(organization_id,code,name) VALUES(2,'SECOND','Second')`},
		{"multiple locations", `INSERT INTO warehouse_locations(warehouse_id,code,name) VALUES(2,'SECOND','Second')`},
		{"cross-company parent", `UPDATE material_categories SET parent_id=1 WHERE id=2`},
		{"cross-company category", `UPDATE materials SET category_id=1 WHERE id=2`},
		{"cross-company unit", `UPDATE materials SET base_unit_id=1 WHERE id=2`},
		{"rule category", `INSERT INTO code_rules(organization_id,category_id,prefix,sequence_length) VALUES(2,1,'X',4)`},
		{"no effective grant", `DELETE FROM user_organizations WHERE user_id=1`},
		{"empty application", `DELETE FROM application_items WHERE application_id=1`},
		{"mixed application", `INSERT INTO application_items(application_id,material_id,quantity) VALUES(1,1,1)`},
		{"orphan log", `UPDATE stock_logs SET related_order_id=999 WHERE id=1`},
		{"wrong log material", `UPDATE stock_logs SET material_id=1 WHERE id=1`},
		{"unknown log type", `UPDATE stock_logs SET related_order_type='unknown' WHERE id=1`},
		{"balance dimensions", `UPDATE inventory_balances SET warehouse_id=1 WHERE material_id=2`},
		{"warning dimensions", `INSERT INTO stock_warning_rules(organization_id,warehouse_id,material_id) VALUES(2,1,2)`},
		{"order dimensions", `UPDATE inbound_orders SET location_id=1 WHERE id=1`},
		{"order material", `UPDATE inbound_items SET material_id=1 WHERE inbound_order_id=1`},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			db := isolationDB(t, true)
			seedIsolationHistory(t, db)
			mustSQL(t, db, tc.query)
			err := upgradeIsolation(db)
			if err == nil || !strings.Contains(err.Error(), "integrity anomalies") {
				t.Fatalf("invalid history must block with integrity error, got %v", err)
			}
			var count int
			if err := db.QueryRow(`SELECT COUNT(*) FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='stock_logs' AND column_name='organization_id'`).Scan(&count); err != nil || count != 0 {
				t.Fatalf("blocked upgrade changed business schema: %d %v", count, err)
			}
		})
	}
}