// vtest build: present_sqlite3? && !sanitize-memory-clang
import db.sqlite
import orm

struct TxUser {
	id   int @[primary; sql: serial]
	name string
}

fn setup_tx_db() !sqlite.DB {
	mut db := sqlite.connect(':memory:')!
	sql db {
		create table TxUser
	}!
	return db
}

fn insert_callback_user(mut tx orm.Tx) !int {
	user := TxUser{
		name: 'callback_commit'
	}
	sql tx {
		insert user into TxUser
	}!
	return tx.last_id()
}

fn insert_and_fail(mut tx orm.Tx) !int {
	user := TxUser{
		name: 'callback_rollback'
	}
	sql tx {
		insert user into TxUser
	}!
	return error('force rollback')
}

fn nested_success_inner(mut tx orm.Tx) !int {
	user := TxUser{
		name: 'nested_success'
	}
	sql tx {
		insert user into TxUser
	}!
	return tx.last_id()
}

fn nested_failure_inner(mut tx orm.Tx) !int {
	user := TxUser{
		name: 'nested_failure'
	}
	sql tx {
		insert user into TxUser
	}!
	return error('nested failure')
}

fn count_tx_users(db sqlite.DB) !int {
	return db.q_int('select count(*) from TxUser')!
}

fn tx_user_names(db sqlite.DB) ![]string {
	rows := sql db {
		select from TxUser order by id
	}!
	return rows.map(it.name)
}

fn test_transaction_callback_commits_on_success() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	id := orm.transaction[int](mut db, insert_callback_user)!
	assert id == 1
	assert count_tx_users(db)! == 1
	assert tx_user_names(db)! == ['callback_commit']
}

fn test_transaction_callback_rolls_back_on_error() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	orm.transaction[int](mut db, insert_and_fail) or {
		assert err.msg() == 'force rollback'
		assert count_tx_users(db)! == 0
		return
	}
	assert false
}

fn test_manual_begin_with_sql_tx_queries() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	mut tx := orm.begin(mut db)!
	user := TxUser{
		name: 'manual'
	}
	sql tx {
		insert user into TxUser
	}!
	inserted := sql tx {
		select from TxUser where name == 'manual'
	}!
	assert inserted.len == 1
	assert inserted[0].name == 'manual'

	sql tx {
		update TxUser set name = 'manual_updated' where name == 'manual'
	}!
	updated := sql tx {
		select from TxUser where name == 'manual_updated'
	}!
	assert updated.len == 1

	sql tx {
		delete from TxUser where name == 'manual_updated'
	}!
	assert count_tx_users(db)! == 0
	tx.commit()!
}

fn test_query_builder_works_inside_transaction() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	mut tx := orm.begin(mut db)!
	mut qb := orm.new_query[TxUser](tx)
	qb.insert(TxUser{
		name: 'qb_user'
	})!

	selected := qb.where('name = ?', 'qb_user')!.query()!
	assert selected.len == 1
	assert selected[0].name == 'qb_user'

	tx.commit()!
	assert tx_user_names(db)! == ['qb_user']
}

fn test_nested_transaction_success_releases_savepoint() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	orm.transaction[int](mut db, fn (mut tx orm.Tx) !int {
		before := TxUser{
			name: 'outer_before'
		}
		sql tx {
			insert before into TxUser
		}!

		nested_id := tx.transaction[int](nested_success_inner)!
		after := TxUser{
			name: 'outer_after'
		}
		sql tx {
			insert after into TxUser
		}!
		return nested_id
	})!

	assert tx_user_names(db)! == ['outer_before', 'nested_success', 'outer_after']
}

fn test_nested_transaction_failure_rolls_back_inner_work_only() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	orm.transaction[int](mut db, fn (mut tx orm.Tx) !int {
		before := TxUser{
			name: 'outer_before'
		}
		sql tx {
			insert before into TxUser
		}!

		tx.transaction[int](nested_failure_inner) or {}

		after := TxUser{
			name: 'outer_after'
		}
		sql tx {
			insert after into TxUser
		}!
		return 0
	})!

	assert tx_user_names(db)! == ['outer_before', 'outer_after']
}

fn test_manual_savepoint_rollback_and_release() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	mut tx := orm.begin(mut db)!
	before := TxUser{
		name: 'before_savepoint'
	}
	sql tx {
		insert before into TxUser
	}!

	mut sp := tx.savepoint()!
	rollback_user := TxUser{
		name: 'rollback_me'
	}
	sql tx {
		insert rollback_user into TxUser
	}!
	sp.rollback()!

	after := TxUser{
		name: 'after_rollback'
	}
	sql tx {
		insert after into TxUser
	}!

	mut sp2 := tx.savepoint()!
	released := TxUser{
		name: 'keep_me'
	}
	sql tx {
		insert released into TxUser
	}!
	sp2.release()!

	tx.commit()!
	assert tx_user_names(db)! == ['before_savepoint', 'after_rollback', 'keep_me']
}

fn test_inactive_transaction_errors() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	mut tx := orm.begin(mut db)!
	tx.commit()!

	tx.commit() or { assert err.msg().contains('inactive') }

	user := TxUser{
		name: 'after_close'
	}
	sql tx {
		insert user into TxUser
	} or {
		assert err.msg().contains('inactive')
		return
	}
	assert false
}

fn test_inactive_savepoint_errors() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	mut tx := orm.begin(mut db)!
	mut sp := tx.savepoint()!
	sp.release()!
	sp.rollback() or {
		assert err.msg().contains('inactive')
		tx.rollback()!
		return
	}
	assert false
}

fn test_savepoint_becomes_inactive_when_parent_transaction_closes() {
	mut db := setup_tx_db()!
	defer {
		db.close() or {}
	}

	mut tx := orm.begin(mut db)!
	mut sp := tx.savepoint()!
	tx.commit()!

	sp.release() or {
		assert err.msg().contains('inactive')
		return
	}
	assert false
}