module main

struct Table {
mut:
	types     []Type
	consts    []Var
	fns       []Fn
	obf_ids   map_int // obf_ids 'myfunction'] == 23
	packages  []string // List of all modules registered by the application
	imports   []string // List of all imports
	flags     []string //  ['-framework Cocoa', '-lglfw3']
	fn_cnt    int atomic
	obfuscate bool
}

enum AccessMod {
	PRIVATE        // private immutable
	PRIVET_MUT     // private mutable
	PUBLIC         // public immmutable (readonly)
	PUBLIC_MUT     // public, but mutable only in this module
	PUBLIC_MUT_MUT // public and mutable both inside and outside (not recommended to use, that's why it's so verbose)
}

enum TypeCategory {
	TYPE_STRUCT
	T_CAT_FN
}

struct Type {
mut:
	pkg            string
	name           string
	fields         []Var
	methods        []Fn
	parent         string
	cat            TypeCategory
	gen_types      []string
	func           Fn // For cat == FN (type kek fn())
	is_c           bool // C.FILE
	is_interface   bool
	is_enum        bool
	// This field is used for types that are not defined yet but are known to exist.
	// It allows having things like `fn (f Foo) bar()` before `Foo` is defined.
	// This information is needed in the first pass.
	is_placeholder bool
}

// For debugging types
fn (t Type) str() string {
	mut s := 'type "$t.name" {'
	if t.fields.len > 0 {
		// s += '\n    $t.fields.len fields:\n'
		for field in t.fields {
			s += '\n    $field.name $field.typ'
		}
		s += '\n'
	}
	if t.methods.len > 0 {
		// s += '\n    $t.methods.len methods:\n'
		for method in t.methods {
			s += '\n    ${method.str()}'
		}
		s += '\n'
	}
	s += '}\n'
	return s
}

const (
	CReserved = [
		'exit',
		'unix',
		'print',
		// 'ok',
		'error',
		'malloc',
		'calloc',
		'char',
		'free',
		'panic',
		'register'
	]
	
)

// This is used in generated C code
fn (f Fn) str() string {
	t := Table{}
	str_args := f.str_args(t)
	return '$f.name($str_args) $f.typ'
}

// fn (types array_Type) print_to_file(f string)  {
// }
const (
	NUMBER_TYPES = ['number', 'int', 'i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'byte', 'i64', 'u64', 'long', 'double', 'float', 'f32', 'f64']
	FLOAT_TYPES  = ['double', 'float', 'f32', 'f64']
)

fn is_number_type(typ string) bool {
	return NUMBER_TYPES.contains(typ)
}

fn is_float_type(typ string) bool {
	return FLOAT_TYPES.contains(typ)
}

fn new_table(obfuscate bool) *Table {
	mut t := &Table {
		obf_ids: map[string]int{}
		obfuscate: obfuscate
	}
	t.register_type('int')
	t.register_type('size_t')
	t.register_type_with_parent('i8', 'int')
	t.register_type_with_parent('u8', 'int')
	t.register_type_with_parent('i16', 'int')
	t.register_type_with_parent('u16', 'int')
	t.register_type_with_parent('i32', 'int')
	t.register_type_with_parent('u32', 'int')
	t.register_type_with_parent('byte', 'int')
	// t.register_type_with_parent('i64', 'int')
	t.register_type('i64')
	t.register_type_with_parent('u64', 'int')
	t.register_type('long')
	t.register_type('byteptr')
	t.register_type('intptr')
	t.register_type('double')// TODO remove
	t.register_type('float')// TODO remove
	t.register_type('f32')
	t.register_type('f64')
	t.register_type('rune')
	t.register_type('bool')
	t.register_type('void')
	t.register_type('voidptr')
	t.register_type('va_list')
	t.register_const('stdin', 'int', 'main', false)
	t.register_const('stderr', 'int', 'main', false)
	t.register_type_with_parent('map_string', 'map')
	t.register_type_with_parent('map_int', 'map')
	return t
}

// If `name` is a reserved C keyword, returns `v_name` instead.
fn (t mut Table) var_cgen_name(name string) string {
	if CReserved.contains(name) {
		return 'v_$name'
	}
	else {
		return name
	}
}

fn (t mut Table) register_package(pkg string) {
	if t.packages.contains(pkg) {
		return
	}
	t.packages << pkg
}

fn (table &Table) known_pkg(pkg string) bool {
	return pkg in table.packages
}

fn (t mut Table) register_const(name, typ string, pkg string, is_imported bool) {
	t.consts << Var {
		name: name
		typ: typ
		is_const: true
		is_import_const: is_imported
		pkg: pkg
	}
}

// Only for translated code
fn (p mut Parser) register_global(name, typ string) {
	p.table.consts << Var {
		name: name
		typ: typ
		is_const: true
		is_global: true
		pkg: p.pkg
	}
}

// TODO PERF O(N) this slows down the comiler a lot!
fn (t mut Table) register_fn(f Fn) {
	// Avoid duplicate fn names TODO why? the name should already be unique?
	for ff in t.fns {
		if ff.name == f.name {
			return
		}
	}
	t.fns << f
}

fn (table &Table) known_type(typ string) bool {
	// 'byte*' => look up 'byte', but don't mess up fns
	if typ.ends_with('*') && !typ.contains(' ') {
		typ = typ.left(typ.len - 1)
	}
	for t in table.types {
		if t.name == typ && !t.is_placeholder {
			return true
		}
	}
	return false
}

// TODO PERF O(N) this slows down the comiler a lot!
fn (t &Table) find_fn(name string) Fn {
	for f in t.fns {
		if f.name == name {
			return f
		}
	}
	return Fn{}
}

// TODO PERF O(N) this slows down the comiler a lot!
fn (t &Table) known_fn(name string) bool {
	for f in t.fns {
		if f.name == name {
			return true
		}
	}
	return false
}

fn (t &Table) known_const(name string) bool {
	v := t.find_const(name)
	// TODO use optional
	return v.name.len > 0
}

fn (t mut Table) register_type(typ string) {
	if typ.len == 0 {
		return
	}
	// println('REGISTER TYPE $typ')
	for typ2 in t.types {
		if typ2.name == typ {
			return
		}
	}
	// if t.types.filter( _.name == typ.name).len > 0 {
	// return
	// }
	datyp := Type {
		name: typ
	}
	t.types << datyp
}

fn (p mut Parser) register_type_with_parent(strtyp, parent string) {
	typ := Type {
		name: strtyp
		parent: parent
		pkg: p.pkg
	}
	p.table.register_type2(typ)
}

fn (t mut Table) register_type_with_parent(typ, parent string) {
	if typ.len == 0 {
		return
	}
	// if t.types.filter(_.name == typ) > 0
	for typ2 in t.types {
		if typ2.name == typ {
			return
		}
	}
	/* 
mut pkg := '' 
if parent == 'array' {
pkg = 'builtin' 
} 
*/
	datyp := Type {
		name: typ
		parent: parent
	}
	t.types << datyp
}

fn (t mut Table) register_type2(typ Type) {
	if typ.name.len == 0 {
		return
	}
	// println('register type2 $typ.name')
	for typ2 in t.types {
		if typ2.name == typ.name {
			return
		}
	}
	t.types << typ
}

fn (t mut Type) add_field(name, typ string, is_mut bool, attr string, access_mod AccessMod) {
	// if t.name == 'Parser' {
	// println('adding field $name')
	// }
	v := Var {
		name: name
		typ: typ
		is_mut: is_mut
		attr: attr
		access_mod: access_mod
	}
	t.fields << v
}

fn (t &Type) has_field(name string) bool {
	field := t.find_field(name)
	return (field.name != '')
}

fn (t &Type) find_field(name string) Var {
	for field in t.fields {
		if field.name == name {
			return field
		}
	}
	return Var{}
}

fn (table &Table) type_has_field(typ &Type, name string) bool {
	field := table.find_field(typ, name)
	return (field.name != '')
}

fn (table &Table) find_field(typ &Type, name string) Var {
	field := typ.find_field(name)
	if field.name.len == 0 && typ.parent.len > 0 {
		parent := table.find_type(typ.parent)
		return parent.find_field(name)
	}
	return field
}

fn (t mut Type) add_method(f Fn) {
	// if t.name.contains('Parser') {
	// println('!!!add_method() $f.name to $t.name len=$t.methods.len cap=$t.methods.cap')
	// }
	t.methods << f
	// println('end add_method()')
}

fn (t &Type) has_method(name string) bool {
	method := t.find_method(name)
	return (method.name != '')
}

fn (table &Table) type_has_method(typ &Type, name string) bool {
	method := table.find_method(typ, name)
	return (method.name != '')
}

// TODO use `?Fn`
fn (table &Table) find_method(typ &Type, name string) Fn {
	// println('TYPE HAS METHOD $name')
	method := typ.find_method(name)
	if method.name.len == 0 && typ.parent.len > 0 {
		parent := table.find_type(typ.parent)
		return parent.find_method(name)
		// println('parent = $parent.name $res')
		// return res
	}
	return method
}

fn (t &Type) find_method(name string) Fn {
	// println('$t.name find_method($name) methods.len=$t.methods.len')
	for method in t.methods {
		// println('method=$method.name')
		if method.name == name {
			return method
		}
	}
	return Fn{}
}

fn (t mut Type) add_gen_type(type_name string) {
	// println('add_gen_type($s)')
	if t.gen_types.contains(type_name) {
		return
	}
	t.gen_types << type_name
}

fn (p &Parser) find_type(name string) *Type {
	typ := p.table.find_type(name)
	if typ.name.len == 0 {
		return p.table.find_type(p.prepend_pkg(name))
	}
	return typ
}

fn (t &Table) find_type(name string) *Type {
	if name.ends_with('*') && !name.contains(' ') {
		name = name.left(name.len - 1)
	}
	// TODO PERF use map
	for i, typ in t.types {
		if typ.name == name {
			return &t.types[i]
		}
	}
	return &Type{}
}

fn (p mut Parser) _check_types(got, expected string, throw bool) bool {
	p.log('check types got="$got" exp="$expected"  ')
	if p.translated {
		return true
	}
	// Allow ints to be used as floats
	if got.eq('int') && expected.eq('float') {
		return true
	}
	if got.eq('int') && expected.eq('f64') {
		return true
	}
	if got == 'f64' && expected == 'float' {
		return true
	}
	if got == 'float' && expected == 'f64' {
		return true
	}
	// Allow ints to be used as longs
	if got.eq('int') && expected.eq('long') {
		return true
	}
	if got == 'void*' && expected.starts_with('fn ') {
		return true
	}
	if got.starts_with('[') && expected == 'byte*' {
		return true
	}
	// Todo void* allows everything right now
	if got.eq('void*') || expected.eq('void*') {
		// if !p.builtin_pkg {
		if p.is_play {
			return false
		}
		return true
	}
	// TODO only allow numeric consts to be assigned to bytes, and
	// throw an error if they are bigger than 255
	if got.eq('int') && expected.eq('byte') {
		return true
	}
	if got.eq('int') && expected.eq('byte*') {
		return true
	}
	// byteptr += int
	if got.eq('int') && expected.eq('byteptr') {
		return true
	}
	if got == 'Option' && expected.starts_with('Option_') {
		return true
	}
	// lines := new_array
	if got == 'array' && expected.starts_with('array_') {
		return true
	}
	// Expected type "Option_os__File", got "os__File"
	if expected.starts_with('Option_') && expected.ends_with(got) {
		return true
	}
	// NsColor* return 0
	if !p.is_play {
		if expected.ends_with('*') && got == 'int' {
			return true
		}
		// if got == 'T' || got.contains('<T>') {
		// return true
		// }
		// if expected == 'T' || expected.contains('<T>') {
		// return true
		// }
		// Allow pointer arithmetic
		if expected.eq('void*') && got.eq('int') {
			return true
		}
	}
	expected = expected.replace('*', '')
	got = got.replace('*', '')
	if got != expected {
		// Interface check
		if expected.ends_with('er') {
			if p.satisfies_interface(expected, got, throw) {
				return true
			}
		}
		if !throw {
			return false
		}
		else {
			p.error('expected type `$expected`, but got `$got`')
		}
	}
	return true
}

// throw by default
fn (p mut Parser) check_types(got, expected string) bool {
	return p._check_types(got, expected, true)
}

fn (p mut Parser) check_types_no_throw(got, expected string) bool {
	return p._check_types(got, expected, false)
}

fn (p mut Parser) satisfies_interface(interface_name, _typ string, throw bool) bool {
	int_typ := p.table.find_type(interface_name)
	typ := p.table.find_type(_typ)
	for method in int_typ.methods {
		if !typ.has_method(method.name) {
			// if throw {
			p.error('Type "$_typ" doesnt satisfy interface "$interface_name" (method "$method.name" is not implemented)')
			// }
			return false
		}
	}
	return true
}

fn type_default(typ string) string {
	if typ.starts_with('array_') {
		typ = typ.right(6)
		return 'new_array(0, 1, sizeof($typ))'
	}
	// Always set pointers to 0
	if typ.ends_with('*') {
		return '0'
	}
	// ?
	if typ.contains('__') {
		return ''
	}
	// Default values for other types are not needed because of mandatory initialization
	switch typ {
	case 'int': return '0'
	case 'string': return 'tos("", 0)'
	case 'void*': return '0'
	case 'byte*': return '0'
	case 'bool': return '0'
	}
	return ''
}

// TODO PERF O(n)
fn (t &Table) is_interface(name string) bool {
	for typ in t.types {
		if typ.is_interface && typ.name == name {
			return true
		}
	}
	return false
}

// Do we have fn main()?
fn (t &Table) main_exists() bool {
	for f in t.fns {
		if f.name == 'main' {
			return true
		}
	}
	return false
}

// TODO use `?Var`
fn (t &Table) find_const(name string) Var {
	for c in t.consts {
		if c.name == name {
			return c
		}
	}
	return Var{}
}

fn (table mut Table) cgen_name(f &Fn) string {
	mut name := f.name
	if f.is_method {
		name = '${f.receiver_typ}_$f.name'
		name = name.replace(' ', '')
		name = name.replace('*', '')
		name = name.replace('+', 'plus')
		name = name.replace('-', 'minus')
	}
	// Avoid name conflicts (with things like abs(), print() etc).
	// Generate b_abs(), b_print()
	// TODO duplicate functionality
	if f.pkg == 'builtin' && CReserved.contains(f.name) {
		return 'v_$name'
	}
	// Obfuscate but skip certain names
	// TODO ugly, fix
	if table.obfuscate && f.name != 'main' && f.name != 'WinMain' && f.pkg != 'builtin' && !f.is_c &&
	f.pkg != 'darwin' && f.pkg != 'os' && !f.name.contains('window_proc') && f.name != 'gg__vec2' &&
	f.name != 'build_token_str' && f.name != 'build_keys' && f.pkg != 'json' &&
	!name.ends_with('_str') && !name.contains('contains') {
		mut idx := table.obf_ids[name]
		// No such function yet, register it
		if idx == 0 {
			table.fn_cnt++
			table.obf_ids[name] = table.fn_cnt
			idx = table.fn_cnt
		}
		old := name
		name = 'f_$idx'
		println2('$old ==> $name')
	}
	return name
}

// ('s', 'string') => 'string s'
// ('nums', '[20]byte') => 'byte nums[20]'
// ('myfn', 'fn(int) string') => 'string (*myfn)(int)'
fn (table &Table) cgen_name_type_pair(name, typ string) string {
	// Special case for [10]int
	if typ.len > 0 && typ[0] == `[` {
		tmp := typ.all_after(']')
		size := typ.all_before(']')
		return '$tmp $name  $size ]'
	}
	// fn()
	else if typ.starts_with('fn (') {
		T := table.find_type(typ)
		if T.name == '' {
			os.exit1('this should never happen')
		}
		str_args := T.func.str_args(table)
		return '$T.func.typ (*$name)( $str_args /*FFF*/ )'
	}
	// TODO tm hack, do this for all C struct args
	else if typ == 'tm' {
		return 'struct tm $name'
	}
	return '$typ $name'
}