import db.sqlite
import time

struct Person {
	name   string
	height Height
}

enum Height as u8 {
	tall
	small
}

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

	sql db {
		create table Person
	}!

	a := Person{'A', Height.small}
	b := Person{'A', Height.tall}

	sql db {
		insert a into Person
	}!

	sql db {
		insert b into Person
	}!

	new_height := Height.small
	sql db {
		update Person set height = new_height where height == Height.tall
	}!

	rows := sql db {
		select from Person where height == Height.small
	}!

	assert rows.len == 2
}

@[table: 'orm_update_users']
struct OrmUpdateUser {
pub:
	id         string @[primary]
	name       string
	updated_at time.Time @[sql_type: 'TIMESTAMP']
}

struct OrmUpdateReq {
	updated_at ?time.Time
}

fn test_orm_update_with_option_selector_or_block() {
	mut db := sqlite.connect(':memory:')!
	defer {
		db.close() or { panic(err) }
	}

	sql db {
		create table OrmUpdateUser
	}!

	user := OrmUpdateUser{
		id:         '100'
		name:       'Alice'
		updated_at: time.unix(1_700_000_000)
	}
	sql db {
		insert user into OrmUpdateUser
	}!

	req := OrmUpdateReq{}
	expected_updated_at := time.unix(1_700_000_123)

	sql db {
		update OrmUpdateUser set updated_at = req.updated_at or { expected_updated_at } where id == '100'
	}!

	rows := sql db {
		select from OrmUpdateUser where id == '100'
	}!

	assert rows.len == 1
	assert rows[0].updated_at.unix() == expected_updated_at.unix()
}

struct OrmUpdateThing {
	id    int @[primary]
	value string
}

struct OrmUpdateCommit {
	id    int @[primary]
	tag   string
	thing OrmUpdateThing
}

fn test_orm_update_with_struct_field() {
	mut db := sqlite.connect(':memory:')!
	defer {
		db.close() or { panic(err) }
	}

	sql db {
		create table OrmUpdateThing
		create table OrmUpdateCommit
	}!

	second := OrmUpdateThing{
		id:    2
		value: 'goodbye'
	}
	sql db {
		insert second into OrmUpdateThing
	}!

	commit := OrmUpdateCommit{
		id:    1
		tag:   'head'
		thing: OrmUpdateThing{
			id:    1
			value: 'hello'
		}
	}
	sql db {
		insert commit into OrmUpdateCommit
	}!

	sql db {
		update OrmUpdateCommit set thing = second where tag == 'head'
	}!

	rows := sql db {
		select from OrmUpdateCommit where tag == 'head'
	}!

	assert rows.len == 1
	assert rows[0].thing.id == second.id
	assert rows[0].thing.value == 'goodbye'
}

struct DynamicOrmUser {
	id              int @[primary; sql: serial]
	simplified_name string
	currency_code   string
}

struct DynamicOrmRequest {
	simplified_name ?string
	currency_code   ?string
}

fn test_dynamic_orm_select_and_update_with_if_guards() {
	mut db := sqlite.connect(':memory:')!
	defer {
		db.close() or { panic(err) }
	}

	sql db {
		create table DynamicOrmUser
	}!

	first := DynamicOrmUser{
		id:              1
		simplified_name: 'usd'
		currency_code:   'USD'
	}
	second := DynamicOrmUser{
		id:              2
		simplified_name: 'eur'
		currency_code:   'EUR'
	}

	sql db {
		insert first into DynamicOrmUser
		insert second into DynamicOrmUser
	}!

	select_req := DynamicOrmRequest{
		simplified_name: ?string('usd')
	}
	where_expr := {
		if name := select_req.simplified_name {
			simplified_name == name
		},
		if code := select_req.currency_code {
			currency_code == code
		}
	}

	rows := sql db {
		dynamic select from DynamicOrmUser where where_expr
	}!

	assert rows.len == 1
	assert rows[0].id == first.id

	update_req := DynamicOrmRequest{
		simplified_name: ?string('dollar')
	}
	set_expr := {
		if name := update_req.simplified_name {
			simplified_name == name
		},
		if code := update_req.currency_code {
			currency_code == code
		}
	}

	sql db {
		dynamic update DynamicOrmUser set set_expr where id == first.id
	}!

	updated_rows := sql db {
		select from DynamicOrmUser where id == first.id
	}!

	assert updated_rows.len == 1
	assert updated_rows[0].simplified_name == 'dollar'
	assert updated_rows[0].currency_code == 'USD'
}