// 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) attrs(attrs []ast.Attr) {
	if attrs_have_call_syntax(attrs) {
		f.call_syntax_attrs(attrs)
		return
	}
	f.legacy_attrs(attrs)
}

fn (mut f Fmt) legacy_attrs(attrs []ast.Attr) {
	mut sorted_attrs := attrs.clone()
	// Sort the attributes. The ones with arguments come first
	sorted_attrs.sort_with_compare(fn (a &ast.Attr, b &ast.Attr) int {
		d := b.arg.len - a.arg.len
		return if d != 0 { d } else { compare_strings(b.arg, a.arg) }
	})
	for i, attr in sorted_attrs {
		if attr.arg.len == 0 {
			f.single_line_attrs(sorted_attrs[i..])
			break
		}
		f.writeln('@[${attr}]')
	}
}

fn (mut f Fmt) call_syntax_attrs(attrs []ast.Attr) {
	mut i := 0
	for i < attrs.len {
		if attrs[i].call_name.len > 0 {
			group, next_idx := attr_call_group(attrs, i)
			f.writeln('@[${attr_call_group_str(group)}]')
			i = next_idx
			continue
		}
		mut j := i
		for j < attrs.len && attrs[j].call_name.len == 0 {
			j++
		}
		f.legacy_attrs(attrs[i..j])
		i = j
	}
}

@[params]
pub struct AttrsOptions {
pub:
	same_line bool
}

pub fn (mut f Fmt) single_line_attrs(attrs []ast.Attr, options AttrsOptions) {
	if attrs.len == 0 {
		return
	}
	if attrs_have_call_syntax(attrs) {
		if options.same_line {
			f.write(' ')
		}
		f.write('@[')
		f.write(single_line_attrs_text(attrs))
		f.write(']')
		if !options.same_line {
			f.writeln('')
		}
		return
	}
	f.legacy_single_line_attrs(attrs, options)
}

fn (mut f Fmt) legacy_single_line_attrs(attrs []ast.Attr, options AttrsOptions) {
	mut sorted_attrs := attrs.clone()
	sorted_attrs.sort(a.name < b.name)
	if options.same_line {
		f.write(' ')
	}
	f.write('@[')
	for i, attr in sorted_attrs {
		if i > 0 {
			f.write('; ')
		}
		f.write('${attr}')
	}
	f.write(']')
	if !options.same_line {
		f.writeln('')
	}
}

fn inline_attrs_len(attrs []ast.Attr) int {
	if attrs.len == 0 {
		return 0
	}
	return 3 + single_line_attrs_text(attrs).len // ' [' + ']'.len
}

fn attrs_have_call_syntax(attrs []ast.Attr) bool {
	return attrs.any(it.call_name.len > 0)
}

fn single_line_attrs_text(attrs []ast.Attr) string {
	if !attrs_have_call_syntax(attrs) {
		mut sorted_attrs := attrs.clone()
		sorted_attrs.sort(a.name < b.name)
		mut parts := []string{cap: sorted_attrs.len}
		for attr in sorted_attrs {
			parts << '${attr}'
		}
		return parts.join('; ')
	}
	mut parts := []string{}
	mut i := 0
	for i < attrs.len {
		if attrs[i].call_name.len > 0 {
			group, next_idx := attr_call_group(attrs, i)
			parts << attr_call_group_str(group)
			i = next_idx
			continue
		}
		parts << '${attrs[i]}'
		i++
	}
	return parts.join('; ')
}

fn attr_call_group(attrs []ast.Attr, start int) ([]ast.Attr, int) {
	first := attrs[start]
	mut end := start + 1
	for end < attrs.len && attrs[end].call_name == first.call_name
		&& attrs[end].pos.pos == first.pos.pos {
		end++
	}
	return attrs[start..end], end
}

fn attr_call_group_str(attrs []ast.Attr) string {
	if attrs.len == 0 {
		return ''
	}
	mut ordered_attrs := attrs.clone()
	ordered_attrs.sort(a.call_arg_idx < b.call_arg_idx)
	mut args := []string{}
	for attr in ordered_attrs {
		if !attr.has_arg {
			continue
		}
		mut arg := ''
		if attr.call_arg_name.len > 0 {
			arg += '${attr.call_arg_name}: '
		}
		arg += attr_value_str(attr)
		args << arg
	}
	if args.len == 0 {
		return '${attrs[0].call_name}()'
	}
	return '${attrs[0].call_name}(${args.join(', ')})'
}

fn attr_value_str(attr ast.Attr) string {
	quote := if attr.quote == `"` { '"' } else { "'" }
	return match attr.kind {
		.plain, .number, .bool { attr.arg }
		.string { '${quote}${attr.arg}${quote}' }
		.comptime_define { 'if ${attr.arg}' }
	}
}