// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module fmt

import v.ast

pub fn (mut f Fmt) struct_decl(node ast.StructDecl, is_anon bool) {
	f.attrs(node.attrs)
	if node.is_pub && !is_anon {
		f.write('pub ')
	}
	if node.is_option {
		f.write('?')
	}
	if node.is_union {
		f.write('union')
	} else {
		f.write('struct')
	}
	name := node.name.after('.') // strip prepended module
	if !is_anon {
		f.write(' ')
		f.write_language_prefix(node.language)
		f.write(name)
	}
	f.write_generic_types(node.generic_types)
	if node.is_implements {
		f.write(' implements ')
		for i, t in node.implements_types {
			f.write(f.table.type_to_str_using_aliases(t.typ, f.mod2alias))
			if i < node.implements_types.len - 1 {
				f.write(', ')
			}
		}
	}
	if node.fields.len == 0 && node.embeds.len == 0 && node.pos.line_nr == node.pos.last_line {
		f.writeln(' {}')
		return
	}
	mut type_align := new_field_align(use_break_line: true)
	mut default_expr_align := new_field_align(use_threshold: true)
	mut attr_align := new_field_align(use_threshold: true)
	mut comment_align := new_field_align(use_threshold: true)
	mut field_types := []string{cap: node.fields.len}
	// Calculate the alignments first
	f.calculate_alignment(node.fields, mut type_align, mut comment_align, mut default_expr_align, mut
		attr_align, mut field_types)
	f.writeln(' {')
	if node.pre_comments.len > 0 {
		f.comments_before_field(node.pre_comments)
	}
	for embed in node.embeds {
		styp := f.table.type_to_str_using_aliases(embed.typ, f.mod2alias)

		pre_comments := embed.comments.filter(it.pos.pos < embed.pos.pos)
		comments := embed.comments[pre_comments.len..]

		f.comments_before_field(pre_comments)
		if comments.len == 0 {
			f.writeln('\t${styp}')
		} else {
			f.write('\t${styp}')
			f.comments(comments, level: .indent)
		}
	}
	// Now handle each field
	mut inc_indent := false // for correct indents with multi line default exprs
	for i, field in node.fields {
		match true {
			i == node.mut_pos {
				f.writeln('mut:')
			}
			i == node.pub_pos {
				f.writeln('pub:')
			}
			i == node.pub_mut_pos {
				f.writeln('pub mut:')
			}
			i == node.global_pos {
				f.writeln('__global:')
			}
			i == node.module_pos {
				f.writeln('module:')
			}
			i > 0 && field.has_prev_newline {
				f.writeln('')
			}
			else {}
		}

		// Handle comments before the field
		if field.pre_comments.len > 0 {
			f.comments(field.pre_comments, level: .indent)
		}
		volatile_prefix := if field.is_volatile { 'volatile ' } else { '' }
		f.write('\t${volatile_prefix}${field.name} ')
		f.write(' '.repeat(type_align.max_len(field.pos.line_nr) - field.name.len))
		// Handle anon structs recursively
		if !f.write_anon_struct_field_decl(field.typ, field.anon_struct_decl) {
			f.write(field_types[i])
		}
		attrs_len := inline_attrs_len(field.attrs)
		if field.has_default_expr {
			f.write(' '.repeat(default_expr_align.max_len(field.pos.line_nr) - field_types[i].len))
			f.write(' = ')
			default_expr_pos := field.default_expr.pos()
			if default_expr_pos.line_nr < default_expr_pos.last_line
				|| !expr_is_single_line(field.default_expr) {
				f.indent++
				inc_indent = true
			}
			f.expr(field.default_expr)
			if inc_indent {
				f.indent--
				inc_indent = false
			}
		}
		if field.attrs.len > 0 {
			f.write(' '.repeat(attr_align.max_len(field.pos.line_nr) - field_types[i].len))
			f.single_line_attrs(field.attrs, same_line: true)
		}
		// Handle comments at the end of the line
		if field.comments.len > 0 {
			if field.has_default_expr {
				f.write(' '.repeat(comment_align.max_len(field.pos.line_nr) -
					field.default_expr.str().len - 2))
			} else if field.attrs.len > 0 {
				f.write(' '.repeat(comment_align.max_len(field.pos.line_nr) - attrs_len))
			} else {
				f.write(' '.repeat(comment_align.max_len(field.pos.line_nr) - field_types[i].len))
			}
			f.write(' ')
			f.comments(field.comments, level: .indent)
		} else {
			f.writeln('')
		}
		// Handle comments on the next lines
		if field.next_comments.len > 0 {
			f.comments(field.next_comments, level: .indent)
		}
	}
	if is_anon || node.end_comments.len > 0 {
		f.write('}')
	} else {
		f.writeln('}')
	}
	if node.end_comments.len > 0 {
		f.comments(node.end_comments, same_line: true)
	}
}

fn (mut f Fmt) write_anon_struct_field_decl(field_typ ast.Type, field_anon_decl ast.StructDecl) bool {
	sym := f.table.sym(field_typ)
	match sym.kind {
		.struct {
			info := sym.info as ast.Struct
			if info.is_anon {
				f.indent++
				if info.is_shared {
					f.write('shared ')
				}
				f.struct_decl(field_anon_decl, true)
				f.indent--
				return true
			}
		}
		.array {
			if sym.info is ast.Array {
				elem_sym := f.table.sym(sym.info.elem_type)
				if elem_sym.info is ast.Struct {
					if elem_sym.info.is_anon {
						if field_typ.has_flag(.option) {
							f.write('?')
						}
						f.write('[]'.repeat(sym.info.nr_dims))
						f.write_anon_struct_field_decl(sym.info.elem_type, field_anon_decl)
						return true
					}
				}
			}
		}
		.array_fixed {
			if sym.info is ast.ArrayFixed {
				elem_sym := f.table.sym(sym.info.elem_type)
				if elem_sym.info is ast.Struct {
					if elem_sym.info.is_anon {
						f.write('[${sym.info.size}]')
						f.write_anon_struct_field_decl(sym.info.elem_type, field_anon_decl)
						return true
					}
				}
			}
		}
		else {}
	}

	return false
}

fn (mut f Fmt) write_anon_struct_type(typ ast.Type) bool {
	sym := f.table.sym(typ)
	if sym.info is ast.Struct && sym.info.is_anon {
		f.struct_decl(ast.StructDecl{
			fields: sym.info.fields
		}, true)
		return true
	}
	return false
}

pub fn (mut f Fmt) struct_init(node ast.StructInit) {
	struct_init_save := f.is_struct_init
	f.is_struct_init = true
	defer {
		f.is_struct_init = struct_init_save
	}
	use_type_expr := node.typ_expr !is ast.EmptyExpr && node.typ == ast.void_type
	sym_name := if use_type_expr { '' } else { f.table.sym(node.typ).name }
	// f.write('<old name: ${type_sym.name}>')
	mut name := if !sym_name.starts_with('C.') && !sym_name.starts_with('JS.') {
		f.no_cur_mod(f.short_module(sym_name)) // TODO: f.type_to_str?
	} else {
		sym_name
	}
	if name == 'void' {
		name = ''
	}
	if node.typ.has_flag(.option) {
		f.write('?')
	}
	if node.is_anon {
		// Write the full anonymous struct definition inline, e.g.:
		// `struct { foo string; bar int }{}`
		sym := f.table.sym(node.typ)
		if sym.info is ast.Struct && sym.info.is_anon {
			f.writeln('struct {')
			f.indent++
			for field in sym.info.fields {
				f.write(field.name)
				f.write(' ')
				f.write(f.table.type_to_str_using_aliases(field.typ, f.mod2alias))
				f.writeln('')
			}
			f.indent--
			f.write('}')
			if node.init_fields.len == 0 && !node.has_update_expr {
				f.write('{}')
			} else {
				f.writeln('{')
				f.indent++
				for init_field in node.init_fields {
					f.write('${init_field.name}: ')
					f.expr(init_field.expr)
					f.writeln('')
				}
				f.indent--
				f.write('}')
			}
			return
		}
		f.write('struct ')
	}
	if node.init_fields.len == 0 && !node.has_update_expr {
		// `Foo{}` on one line if there are no fields or comments
		if node.pre_comments.len == 0 {
			if use_type_expr {
				f.expr(node.typ_expr)
				f.write('{}')
			} else {
				f.write('${name}{}')
			}
		} else {
			if use_type_expr {
				f.expr(node.typ_expr)
				f.writeln('{')
			} else {
				f.writeln('${name}{')
			}
			f.comments(node.pre_comments, same_line: true, has_nl: true, level: .indent)
			f.write('}')
		}
	} else if node.no_keys {
		// `Foo{1,2,3}` (short syntax, no keys)
		if use_type_expr {
			f.expr(node.typ_expr)
			f.write('{')
		} else {
			f.write('${name}{')
		}
		if node.has_update_expr {
			f.write('...')
			f.expr(node.update_expr)
			f.write(', ')
		}
		for i, init_field in node.init_fields {
			f.expr(init_field.expr)
			if i < node.init_fields.len - 1 {
				f.write(', ')
			}
		}
		f.write('}')
	} else {
		use_short_args := f.use_short_fn_args && !node.has_update_expr
		f.use_short_fn_args = false
		mut single_line_fields := f.single_line_fields
		f.single_line_fields = false
		if node.pos.line_nr < node.pos.last_line || node.pre_comments.len > 0 {
			single_line_fields = false
		}
		if !use_short_args || node.is_anon {
			if use_type_expr {
				f.expr(node.typ_expr)
				f.write('{')
			} else {
				f.write('${name}{')
			}
			if single_line_fields {
				f.write(' ')
			}
		}
		fields_start := f.out.len
		fields_loop: for {
			if !single_line_fields {
				if use_short_args && f.out.last() == ` ` {
					//           v Remove space at tail of line
					// f(a, b, c, \n
					//     f1: 0\n
					//     f2: 1\n
					// )
					f.out.go_back(1)
				}
				f.writeln('')
				f.indent++
			}
			f.comments(node.pre_comments, same_line: true, has_nl: true, level: .keep)
			if node.has_update_expr {
				f.write('...')
				f.expr(node.update_expr)
				if single_line_fields {
					if node.init_fields.len > 0 {
						f.write(', ')
					}
				} else {
					f.writeln('')
				}
				f.comments(node.update_expr_comments, same_line: true, has_nl: true, level: .keep)
			}
			mut value_align := new_field_align(use_break_line: true)
			mut comment_align := new_field_align(use_threshold: true)
			for init_field in node.init_fields {
				value_align.add_info(init_field.name.len, init_field.pos.line_nr,
					init_field.has_break_line)
				if init_field.end_comments.len > 0 {
					comment_align.add_info(init_field.expr.str().len, init_field.pos.line_nr,
						init_field.has_break_line)
				}
			}
			for i, init_field in node.init_fields {
				if i > 0 && init_field.has_prev_newline {
					f.writeln('')
				}
				if init_field.pre_comments.len > 0 {
					f.comments(init_field.pre_comments, has_nl: true, level: .keep)
				}
				f.write('${init_field.name}: ')
				if !single_line_fields {
					f.write(' '.repeat(value_align.max_len(init_field.pos.line_nr) - init_field.name.len))
				}
				f.expr(init_field.expr)
				if init_field.end_comments.len > 0 {
					f.write(' '.repeat(comment_align.max_len(init_field.pos.line_nr) -
						init_field.expr.str().len + 1))
					f.comments(init_field.end_comments, has_nl: false, level: .indent)
				}
				if single_line_fields {
					if i < node.init_fields.len - 1 {
						f.write(', ')
					}
				} else {
					f.writeln('')
				}
				f.comments(init_field.next_comments, has_nl: true, level: .keep)
				if single_line_fields && (init_field.end_comments.len > 0
					|| init_field.next_comments.len > 0
					|| !expr_is_single_line(init_field.expr) || f.line_len > max_len) {
					single_line_fields = false
					f.out.go_back_to(fields_start)
					f.line_len = fields_start
					f.remove_new_line()
					continue fields_loop
				}
			}
			break
		}
		if !single_line_fields {
			f.indent--
		}
		if !use_short_args || node.is_anon {
			if single_line_fields {
				f.write(' ')
			}
			f.write('}')
		}
	}
}