// vtest build: present_sqlite3? && !windows && !sanitize-memory-clang
// vtest retry: 3
// Tests for generic structs where the type parameter is used as a field type
import db.sqlite

// Test struct that will be used as a generic type parameter
struct Payload {
	some_field_1 string
	some_field_2 int
}

// Generic struct with a field of type T - this requires proper ORM configuration
// The payload field will be treated as a foreign key reference
pub struct Message[T] {
	id      int @[primary; sql: serial]
	data    string
	payload T @[fkey: 'id']
}

// Payload needs to be a proper ORM table with a primary key
struct PayloadTable {
	id           int @[primary; sql: serial]
	some_field_1 string
	some_field_2 int
}

// Generic struct with proper ORM configuration
pub struct MessageWithPayload[T] {
	id      int @[primary; sql: serial]
	data    string
	payload T @[fkey: 'id']
}

fn test_generic_struct_with_struct_field_and_primary_key() {
	mut db := sqlite.connect(':memory:')!

	// Create tables - PayloadTable first since it's referenced
	sql db {
		create table PayloadTable
	}!

	// Insert a payload
	payload := PayloadTable{
		some_field_1: 'test'
		some_field_2: 42
	}
	sql db {
		insert payload into PayloadTable
	}!

	// Verify the payload was inserted
	payloads := sql db {
		select from PayloadTable
	}!
	assert payloads.len == 1
	assert payloads[0].some_field_1 == 'test'
	assert payloads[0].some_field_2 == 42

	db.close()!
}

// Test that generic structs with simple fields work correctly
pub struct SimpleMessage[T] {
	id     int @[primary; sql: serial]
	data   string
	status int
}

fn test_generic_struct_with_simple_fields() {
	mut db := sqlite.connect(':memory:')!

	sql db {
		create table SimpleMessage[Payload]
	}!

	// The table should be created successfully
	// Note: SimpleMessage[Payload] doesn't actually use Payload as a field type,
	// so this works fine

	db.close()!
}

// Test that skipping struct fields with @[sql: '-'] works
pub struct MessageWithSkippedField[T] {
	id      int @[primary; sql: serial]
	data    string
	payload T @[sql: '-'] // Skip this field in ORM
}

fn test_generic_struct_with_skipped_field() {
	mut db := sqlite.connect(':memory:')!

	// This should work because the payload field is skipped
	sql db {
		create table MessageWithSkippedField[Payload]
	}!

	db.close()!
}

// Test generic struct creation inside a generic function
// This tests the fix for issue #26433
pub struct GenericMessage[T] {
	id      int @[primary; sql: serial]
	data    string
	payload T @[sql: '-'] // Skipped to avoid needing fkey setup
}

pub struct Queue[T] {
pub mut:
	conn &sqlite.DB
}

pub fn create_queue[T](path string) !Queue[T] {
	mut conn := sqlite.connect(path)!

	mut queue := Queue[T]{
		conn: &conn
	}

	// This should work: creating a table with a generic struct inside a generic function
	sql queue.conn {
		create table GenericMessage[T]
	}!

	return queue
}

fn test_create_table_in_generic_function() {
	mut queue := create_queue[Payload](':memory:')!

	// Verify the table was created by inserting and selecting data
	msg := GenericMessage[Payload]{
		data: 'test message'
	}
	sql queue.conn {
		insert msg into GenericMessage[Payload]
	}!

	messages := sql queue.conn {
		select from GenericMessage[Payload]
	}!

	assert messages.len == 1
	assert messages[0].data == 'test message'

	queue.conn.close()!
}

// Test inserting from within a generic function
// This tests the fix for the "cannot use `Message` as `Message[Payload]`" error
pub fn (mut q Queue[T]) add_message(data string) !GenericMessage[T] {
	msg := GenericMessage[T]{
		data: data
	}
	sql q.conn {
		insert msg into GenericMessage[T]
	}!
	return msg
}

fn test_insert_in_generic_function() {
	mut queue := create_queue[Payload](':memory:')!

	// Insert from within a generic function
	msg := queue.add_message('inserted from generic fn')!
	assert msg.data == 'inserted from generic fn'

	// Verify it was inserted
	messages := sql queue.conn {
		select from GenericMessage[Payload]
	}!

	assert messages.len == 1
	assert messages[0].data == 'inserted from generic fn'

	queue.conn.close()!
}