module types

// Type aliases type values used by types.
pub type Type = Void
	| Unknown
	| Primitive
	| String
	| Char
	| Rune
	| ISize
	| USize
	| Nil
	| None
	| Array
	| ArrayFixed
	| Channel
	| Map
	| Pointer
	| FnType
	| OptionType
	| ResultType
	| Struct
	| Interface
	| Enum
	| SumType
	| Alias
	| MultiReturn

// Void represents void data used by types.
pub struct Void {
	dummy_ u8
}

// Unknown represents unknown data used by types.
pub struct Unknown {
pub:
	reason string
}

// String represents string data used by types.
pub struct String {
	dummy_ u8
}

// Char represents char data used by types.
pub struct Char {
	dummy_ u8
}

// Rune represents rune data used by types.
pub struct Rune {
	dummy_ u8
}

// ISize represents isize data used by types.
pub struct ISize {
	dummy_ u8
}

// USize represents usize data used by types.
pub struct USize {
	dummy_ u8
}

// Nil represents nil data used by types.
pub struct Nil {
	dummy_ u8
}

// None represents none data used by types.
pub struct None {
	dummy_ u8
}

// Properties lists properties values used by types.
@[flag]
pub enum Properties {
	boolean
	float
	integer
	unsigned
	untyped
}

// Primitive represents primitive data used by types.
pub struct Primitive {
pub:
	props Properties
	size  u8
}

// Array represents array data used by types.
pub struct Array {
pub:
	elem_type Type
}

// ArrayFixed represents array fixed data used by types.
pub struct ArrayFixed {
pub:
	elem_type Type
	len       int
	len_expr  string
}

// Channel represents channel data used by types.
pub struct Channel {
pub:
	elem_type Type
}

// Map represents map data used by types.
pub struct Map {
pub:
	key_type   Type
	value_type Type
}

// Pointer represents pointer data used by types.
pub struct Pointer {
pub:
	base_type Type
}

// FnType represents fn type data used by types.
pub struct FnType {
pub:
	params      []Type
	return_type Type
}

// OptionType represents option type data used by types.
pub struct OptionType {
pub:
	base_type Type
}

// ResultType represents result type data used by types.
pub struct ResultType {
pub:
	base_type Type
}

// Struct represents struct data used by types.
pub struct Struct {
pub:
	name string
}

// Interface represents interface data used by types.
pub struct Interface {
pub:
	name string
}

// Enum represents enum data used by types.
pub struct Enum {
pub:
	name    string
	is_flag bool
}

// SumType represents sum type data used by types.
pub struct SumType {
pub:
	name string
}

// Alias represents alias data used by types.
pub struct Alias {
pub:
	name      string
	base_type Type
}

// MultiReturn represents multi return data used by types.
pub struct MultiReturn {
pub:
	types []Type
}

// StructField represents struct field data used by types.
pub struct StructField {
pub:
	name string
	typ  Type
}

// unwrap_pointer transforms unwrap pointer data for types.
pub fn unwrap_pointer(t Type) Type {
	if t is Pointer {
		return t.base_type
	}
	return t
}

// generic_base_name returns the declaration part of a concrete generic type name.
pub fn generic_base_name(name string) string {
	if name.starts_with('[') {
		return name
	}
	idx := name.index_u8(`[`)
	if idx > 0 {
		return name[..idx]
	}
	return name
}

// is_pointer reports whether is pointer applies in types.
pub fn (t Type) is_pointer() bool {
	return t is Pointer
}

// is_string reports whether is string applies in types.
pub fn (t Type) is_string() bool {
	return t is String
}

// is_integer reports whether is integer applies in types.
pub fn (t Type) is_integer() bool {
	if t is Primitive {
		return t.props.has(.integer)
	}
	return t is Rune || t is ISize || t is USize
}

// is_float reports whether is float applies in types.
pub fn (t Type) is_float() bool {
	if t is Primitive {
		return t.props.has(.float)
	}
	return false
}

// name returns name data for Type.
pub fn (t Type) name() string {
	if t is Void {
		return 'void'
	}
	if t is Unknown {
		return 'unknown'
	}
	if t is Nil {
		return 'nil'
	}
	if t is None {
		return 'none'
	}
	if t is String {
		return 'string'
	}
	if t is Char {
		return 'char'
	}
	if t is Rune {
		return 'rune'
	}
	if t is ISize {
		return 'isize'
	}
	if t is USize {
		return 'usize'
	}
	if t is Primitive {
		return prim_name_from(t.props, t.size)
	}
	if t is Array {
		return '[]${nested_type_name(t.elem_type)}'
	}
	if t is ArrayFixed {
		mut len_text := t.len.str()
		if t.len_expr.len > 0 {
			len_text = t.len_expr
		}
		return '${nested_type_name(t.elem_type)}[${len_text}]'
	}
	if t is Channel {
		return 'chan ${nested_type_name(t.elem_type)}'
	}
	if t is Map {
		return 'map[${nested_type_name(t.key_type)}]${nested_type_name(t.value_type)}'
	}
	if t is Pointer {
		return '&${nested_type_name(t.base_type)}'
	}
	if t is FnType {
		mut s := 'fn('
		for i in 0 .. t.params.len {
			if i > 0 {
				s += ', '
			}
			s += nested_type_name(fn_type_param_type(t, i))
		}
		s += ')'
		if t.return_type !is Void {
			s += ' ${nested_type_name(t.return_type)}'
		}
		return s
	}
	if t is OptionType {
		return '?${nested_type_name(t.base_type)}'
	}
	if t is ResultType {
		return '!${nested_type_name(t.base_type)}'
	}
	if t is Struct {
		return t.name
	}
	if t is Interface {
		return t.name
	}
	if t is Enum {
		return t.name
	}
	if t is SumType {
		return t.name
	}
	if t is Alias {
		return t.name
	}
	if t is MultiReturn {
		mut parts := []string{}
		for i in 0 .. t.types.len {
			parts << nested_type_name(t.types[i])
		}
		return '(${parts.join(', ')})'
	}
	return ''
}

// nested_type_name supports nested type name handling for types.
fn nested_type_name(t Type) string {
	return t.name()
}

// fn_type_param_type supports fn type param type handling for types.
fn fn_type_param_type(f FnType, idx int) Type {
	return f.params[idx]
}

// prim_name_from supports prim name from handling for types.
fn prim_name_from(props Properties, size u8) string {
	if props.has(.boolean) {
		return 'bool'
	}
	if props.has(.integer) {
		if props.has(.unsigned) {
			return match size {
				8 { 'u8' }
				16 { 'u16' }
				32 { 'u32' }
				64 { 'u64' }
				else { 'u${size}' }
			}
		}
		return match size {
			0 { 'int' }
			8 { 'i8' }
			16 { 'i16' }
			32 { 'i32' }
			64 { 'i64' }
			else { 'i${size}' }
		}
	}
	if props.has(.float) {
		return match size {
			32 { 'f32' }
			64 { 'f64' }
			else { 'f${size}' }
		}
	}
	return 'int'
}

// prim_name supports prim name handling for types.
fn prim_name(t Primitive) string {
	if t.props.has(.boolean) {
		return 'bool'
	}
	if t.props.has(.integer) {
		if t.props.has(.unsigned) {
			return match t.size {
				8 { 'u8' }
				16 { 'u16' }
				32 { 'u32' }
				64 { 'u64' }
				else { 'u${t.size}' }
			}
		}
		return match t.size {
			0 { 'int' }
			8 { 'i8' }
			16 { 'i16' }
			32 { 'i32' }
			64 { 'i64' }
			else { 'i${t.size}' }
		}
	}
	if t.props.has(.float) {
		return match t.size {
			32 { 'f32' }
			64 { 'f64' }
			else { 'f${t.size}' }
		}
	}
	return 'int'
}