// vtest build: started_postgres?
module main

import db.pg
import orm

fn test_large_exec() {
	$if !network ? {
		eprintln('> Skipping test ${@FN}, since `-d network` is not passed.')
		eprintln('> This test requires a working postgres server running on localhost.')
		return
	}

	mut db := pg.connect(pg.Config{ user: 'postgres', password: '12345678', dbname: 'postgres' })!
	defer {
		db.close() or {}
	}

	assert db.validate()!

	rows := db.exec('
SELECT ischema.table_schema, c.relname, a.attname, t.typname, t.typalign, t.typlen
  FROM pg_class c
  JOIN information_schema.tables ischema on ischema.table_name = c.relname
  JOIN pg_attribute a ON (a.attrelid = c.oid)
  JOIN pg_type t ON (t.oid = a.atttypid)
WHERE
  a.attnum >= 0
 ')!
	for row in rows {
		// We just need to access the memory to ensure it's properly allocated
		row.str()
	}
}

fn test_prepared() {
	$if !network ? {
		eprintln('> Skipping test ${@FN}, since `-d network` is not passed.')
		eprintln('> This test requires a working postgres server running on localhost.')
		return
	}
	mut db := pg.connect(pg.Config{ user: 'postgres', password: '12345678', dbname: 'postgres' })!
	defer {
		db.close() or {}
	}

	// Prepared statements are session-scoped, so pin a single conn.
	mut c := db.conn()!
	defer {
		c.close() or {}
	}
	c.prepare('test_prepared', 'SELECT NOW(), $1 AS NAME', 1) or { panic(err) }

	result := c.exec_prepared('test_prepared', ['hello world']) or { panic(err) }

	assert result.len == 1
}

fn test_transaction() {
	$if !network ? {
		eprintln('> Skipping test ${@FN}, since `-d network` is not passed.')
		eprintln('> This test requires a working postgres server running on localhost.')
		return
	}

	mut db := pg.connect(pg.Config{ user: 'postgres', password: '12345678', dbname: 'postgres' })!
	defer {
		db.close() or {}
	}
	db.exec('drop table if exists users')!
	db.exec('create table if not exists users (
                        id SERIAL PRIMARY KEY,
                        username TEXT,
						last_name TEXT NULL DEFAULT NULL
                      )')!

	// orm.TransactionalConnection requires a pinned conn (DB is pool-backed
	// and cannot guarantee BEGIN/COMMIT land on the same physical conn).
	mut c := db.conn()!
	mut tc := orm.TransactionalConnection(c)
	mut otx := orm.begin(mut tc)!
	otx.transaction[int](fn (mut tx orm.Tx) !int {
		return 1
	})!
	otx.commit()!
	c.close()!

	mut tx := db.begin()!
	tx.exec("insert into users (username) values ('jackson')")!
	tx.savepoint('savepoint1')!
	tx.exec("insert into users (username) values ('kitty')")!
	tx.rollback_to('savepoint1')!
	tx.exec("insert into users (username) values ('mars')")!
	tx.commit()!

	rows := db.exec('select * from users')!
	for row in rows {
		// We just need to access the memory to ensure it's properly allocated
		dump(row.str())
	}
}

fn test_listen_notify() {
	$if !network ? {
		eprintln('> Skipping test ${@FN}, since `-d network` is not passed.')
		eprintln('> This test requires a working postgres server running on localhost.')
		return
	}

	mut db := pg.connect(pg.Config{ user: 'postgres', password: '12345678', dbname: 'postgres' })!
	defer {
		db.close() or {}
	}

	// LISTEN/NOTIFY is session-scoped; pin a single conn for the test.
	mut c := db.conn()!
	defer {
		c.close() or {}
	}

	// Test listen
	c.listen('test_channel')!

	// Test notify with payload
	c.notify('test_channel', 'hello world')!

	// Consume input to process the notification
	c.consume_input()!

	// Get the notification
	if notification := c.get_notification() {
		assert notification.channel == 'test_channel'
		assert notification.payload == 'hello world'
		assert notification.pid > 0
	} else {
		assert false, 'Expected a notification but got none'
	}

	// Test notify without payload
	c.notify('test_channel', '')!
	c.consume_input()!

	if notification := c.get_notification() {
		assert notification.channel == 'test_channel'
		assert notification.payload == ''
	} else {
		assert false, 'Expected a notification but got none'
	}

	// Test that no more notifications are pending
	assert c.get_notification() == none

	// Test unlisten
	c.unlisten('test_channel')!

	// Test unlisten_all
	c.listen('channel1')!
	c.listen('channel2')!
	c.unlisten_all()!

	// Test socket (should return valid fd)
	socket_fd := c.socket()
	assert socket_fd >= 0
}