package zig

// Id creates an identifier expression.
func Id(name string) *Identifier {
	return &Identifier{Name: name}
}

// Lit creates a literal expression.
func Lit(kind, value string) *Literal {
	return &Literal{Kind: kind, Value: value}
}

// FieldAccess creates a field access expression.
func FieldAccess(recv Expr, field string) *FieldAccessExpr {
	return &FieldAccessExpr{Receiver: recv, Field: field}
}

// Call creates a function call expression.
func Call(fun Expr, args ...Expr) *CallExpr {
	return &CallExpr{Fun: fun, Args: args}
}

// InitList creates an initializer list expression.
func InitList(exprs ...Expr) *InitListExpr {
	if len(exprs) == 0 {
		return &InitListExpr{Empty: true}
	}
	return &InitListExpr{Values: exprs}
}

// DeclareFn creates a function declaration with flags.
func DeclareFn(name string, retType TypeExpr, body *Block, params []*ParamDecl, flags FnFlags) *FnDecl {
	return &FnDecl{
		Name:       name,
		ReturnType: retType,
		Body:       body,
		Flags:      flags,
		Params:     params,
	}
}

// NewExprStmt creates an expression statement.
func NewExprStmt(expr Expr) *ExprStmt {
	return &ExprStmt{Expr: expr}
}

// DeclareVarStmt creates a variable or const declaration statement.
func DeclareVarStmt(constant bool, names []string, typ TypeExpr, value Expr) *VarDeclStmt {
	return &VarDeclStmt{
		Const:   constant,
		Pattern: VarPattern{Names: names},
		Type:    typ,
		Value:   value,
	}
}

// DeclareGlobalVar creates a global variable declaration with flags.
func DeclareGlobalVar(name string, value Expr, flags GlobalVarFlags) *GlobalVarDecl {
	return &GlobalVarDecl{
		Flags: flags,
		Name:  name,
		Value: value,
	}
}

// Return creates a return statement.
func Return(value Expr) *ReturnStmt {
	return &ReturnStmt{Value: value}
}

// If creates an if statement.
func If(cond Expr, then, els Stmt) *IfStmt {
	return &IfStmt{Cond: cond, Then: then, Else: els}
}

// NewBlock creates a block of statements.
func NewBlock(stmts ...Stmt) *Block {
	return &Block{Stmts: stmts}
}

// NewBlock creates a block statement containing a block of statements.
func NewBlockStmt(stmts ...Stmt) *BlockStmt {
	return &BlockStmt{
		Block: &Block{Stmts: stmts},
	}
}

// Try creates a try expression.
func Try(expr Expr) *TryExpr {
	return &TryExpr{Expr: expr}
}

// Binary creates a binary expression.
func Binary(op string, left, right Expr) *BinaryExpr {
	return &BinaryExpr{Op: op, Left: left, Right: right}
}

// Param creates a function parameter declaration.
func Param(name string, typ TypeExpr) *ParamDecl {
	return &ParamDecl{Name: name, Type: typ}
}

// StructDecl creates a struct declaration with the given fields/members.
func StructDecl(fields ...*ContainerMember) *ContainerDecl {
	return &ContainerDecl{
		Kind:   "struct",
		Fields: fields,
	}
}

// Field creates a struct field (optionally with initializer).
func Field(name string, typ TypeExpr, byteAlign *Expr, value Expr) *ContainerMember {
	return &ContainerMember{
		Field: &ContainerField{
			Name:      name,
			Type:      typ,
			ByteAlign: byteAlign,
			Value:     value,
		},
	}
}

// Method creates a method (function declaration) as a struct member.
func Method(fn *FnDecl) *ContainerMember {
	return &ContainerMember{Decl: fn}
}

// OptionalType creates an optional type (?T).
func OptionalType(base TypeExpr) *PrefixTypeExpr {
	return &PrefixTypeExpr{Op: "?", Base: base}
}

// PointerType creates a pointer type (*T).
func PointerType(base TypeExpr) *PrefixTypeExpr {
	return &PrefixTypeExpr{Op: "*", Base: base}
}