import db.sqlite
import rand

const max_file_name_len = 256

fn test_vfs_register() {
	org_default_vfs := sqlite.get_default_vfs()!

	assert org_default_vfs.zName != 0

	vfs_name := 'sometest'
	mut vfs_descr := &sqlite.Sqlite3_vfs{
		zName: vfs_name.str
		iVersion: 2
	}

	if _ := sqlite.get_vfs(vfs_name) {
		panic('expected that vfs is not known')
	}

	vfs_descr.register_as_nondefault() or { panic('vfs register failed ${err}') }

	sqlite.get_vfs(vfs_name)!

	now_default_vfs := sqlite.get_default_vfs()!

	assert now_default_vfs.zName == org_default_vfs.zName

	vfs_descr.unregister() or { panic('vfs unregister failed ${err}') }

	if _ := sqlite.get_vfs(vfs_name) {
		panic('vfs supposedly unregistered yet somehow still foundable')
	}
}

// minimal vfs based on example https://www.sqlite.org/src/doc/trunk/src/test_demovfs.c
fn test_verify_vfs_is_actually_used() {
	wrapped := sqlite.get_default_vfs()!

	vfs_name := 'sometest'
	mut vfs_state := &ExampleVfsState{
		log: []string{cap: 100}
	}
	mut vfs_descr := &sqlite.Sqlite3_vfs{
		iVersion: 2
		szOsFile: int(sizeof(ExampleVfsOpenedFile))
		mxPathname: max_file_name_len
		zName: vfs_name.str
		pAppData: vfs_state
		xOpen: example_vfs_open
		xDelete: example_vfs_delete
		xAccess: example_vfs_access
		xFullPathname: example_vfs_fullpathname
		xDlOpen: wrapped.xDlOpen
		xDlError: wrapped.xDlError
		xDlSym: wrapped.xDlSym
		xDlClose: wrapped.xDlClose
		xRandomness: wrapped.xRandomness
		xSleep: wrapped.xSleep
		xCurrentTime: wrapped.xCurrentTime
		xGetLastError: example_vfs_getlasterror
		xCurrentTimeInt64: wrapped.xCurrentTimeInt64
	}

	vfs_descr.register_as_nondefault()!

	// normally this would be written to disk
	mut db := sqlite.connect_full('foo.db', [.readwrite, .create], vfs_name)!
	assert ['fullpathname from=foo.db to=foo.db}', 'open temp?=false name=foo.db', 'read file=foo.db'] == vfs_state.log
	vfs_state.log.clear()

	db.close()!
	assert ['close file=foo.db'] == vfs_state.log
}

struct ExampleVfsState {
mut:
	log []string
}

struct ExampleVfsOpenedFile {
mut:
	base      sqlite.Sqlite3_file
	name      string
	vfs_state &ExampleVfsState
}

fn to_vfsstate(t &sqlite.Sqlite3_vfs) &ExampleVfsState {
	unsafe {
		p := t.pAppData
		if p == 0 {
			assert false, 'p should not be 0'
		}
		return &ExampleVfsState(p)
	}
}

fn to_vfsopenedfile(t &sqlite.Sqlite3_file) &ExampleVfsOpenedFile {
	unsafe {
		if t == 0 {
			assert false, 't should not be 0'
		}
		return &ExampleVfsOpenedFile(t)
	}
}

fn example_vfs_fullpathname(vfs &sqlite.Sqlite3_vfs, input &char, size_of_output int, output &char) int {
	println('fullpathname called')

	mut vfs_state := to_vfsstate(vfs)

	from := unsafe { cstring_to_vstring(input) }

	unsafe {
		vmemcpy(output, input, from.len)
		output[from.len] = u8(0)
	}
	result := unsafe { cstring_to_vstring(output) }

	vfs_state.log << 'fullpathname from=${from} to=${result}}'

	return sqlite.sqlite_ok
}

fn example_vfs_access(vfs &sqlite.Sqlite3_vfs, zPath &char, flags int, pResOut &int) int {
	println('access called')
	mut vfs_state := &ExampleVfsState{}

	unsafe {
		assert 0 != vfs.pAppData
		vfs_state = &ExampleVfsState(vfs.pAppData)
	}
	vfs_state.log << 'accessed'

	return sqlite.sqlite_ok
}

fn example_vfs_open(vfs &sqlite.Sqlite3_vfs, file_name_or_null_for_tempfile &char, vfs_opened_file &sqlite.Sqlite3_file, in_flags int, out_flags &int) int {
	println('open called')

	mut is_temp := false
	mut file_name := ''

	unsafe {
		if file_name_or_null_for_tempfile == nil {
			is_temp = true
			file_name = rand.uuid_v4()
		} else {
			file_name = cstring_to_vstring(file_name_or_null_for_tempfile)
		}
	}
	mut vfs_state := to_vfsstate(vfs)

	unsafe {
		mut outp := to_vfsopenedfile(vfs_opened_file)
		outp.base.pMethods = &sqlite.Sqlite3_io_methods{
			iVersion: 1
			xClose: example_vfsfile_close
			xRead: example_vfsfile_read
			xWrite: example_vfsfile_write
			xTruncate: example_vfsfile_truncate
			xSync: example_vfsfile_sync
			xFileSize: example_vfsfile_size
			xLock: example_vfsfile_lock
			xUnlock: example_vfsfile_unlock
			xCheckReservedLock: example_vfsfile_checkreservedlock
			xFileControl: example_vfsfile_filecontrol
			xSectorSize: example_vfsfile_sectorsize
			xDeviceCharacteristics: example_vfsfile_devicecharacteristics
		}

		outp.name = file_name.clone()
		outp.vfs_state = vfs_state
	}
	vfs_state.log << 'open temp?=${is_temp} name=${file_name}'

	return sqlite.sqlite_ok
}

fn example_vfsfile_checkreservedlock(file &sqlite.Sqlite3_file, pResOut &int) int {
	println('file checkreservedlock')

	unsafe {
		*pResOut = 0
	}
	return sqlite.sqlite_ok
}

fn example_vfsfile_filecontrol(file &sqlite.Sqlite3_file, op int, arg voidptr) int {
	println('file filecontrol')

	return 0
}

fn example_vfsfile_devicecharacteristics(file &sqlite.Sqlite3_file) int {
	println('file devicecharacteristics')

	return 0
}

fn example_vfsfile_size(file &sqlite.Sqlite3_file, result &i64) int {
	println('file size')

	return sqlite.sqlite_ok
}

fn example_vfsfile_read(file &sqlite.Sqlite3_file, output voidptr, amount int, offset i64) int {
	println('file read')

	assert amount > 0

	mut vfsfile := to_vfsopenedfile(file)

	vfsfile.vfs_state.log << 'read file=${vfsfile.name}'

	unsafe {
		vmemset(output, 0, amount)
	}

	return sqlite.sqlite_ioerr_short_read
}

fn example_vfsfile_truncate(file &sqlite.Sqlite3_file, size i64) int {
	println('file truncate')

	return sqlite.sqlite_ok
}

fn example_vfsfile_sectorsize(file &sqlite.Sqlite3_file) int {
	println('file sectorsize')

	return 0
}

fn example_vfsfile_sync(file &sqlite.Sqlite3_file, flags int) int {
	println('file sync called')

	return sqlite.sqlite_ok
}

fn example_vfsfile_lock(file &sqlite.Sqlite3_file, elock int) int {
	println('file lock called')

	return sqlite.sqlite_ok
}

fn example_vfsfile_unlock(file &sqlite.Sqlite3_file, elock int) int {
	println('file unlock called')

	return sqlite.sqlite_ok
}

fn example_vfsfile_write(file &sqlite.Sqlite3_file, buf voidptr, amount int, offset i64) int {
	println('file write called')

	return sqlite.sqlite_ok
}

fn example_vfsfile_close(file &sqlite.Sqlite3_file) int {
	println('file close called')

	mut vfsfile := to_vfsopenedfile(file)

	vfsfile.vfs_state.log << 'close file=${vfsfile.name}'

	return sqlite.sqlite_ok
}

fn example_vfs_delete(vfs &sqlite.Sqlite3_vfs, name &char, sync_dir int) int {
	println('vfs delete called')

	return sqlite.sqlite_ok
}

fn example_vfs_getlasterror(vfs &sqlite.Sqlite3_vfs, i int, o &char) int {
	println('vfs getlasterror called')

	unsafe {
		*o = 0
	}
	return sqlite.sqlite_ok
}
