package yaml

import (

	"bytes"

	"fmt"

)

// Flush the buffer if needed.

func flush(emitter *yaml_emitter_t) bool {

	if emitter.buffer_pos+5 >= len(emitter.buffer) {

		return yaml_emitter_flush(emitter)

	}

	return true

}

// Put a character to the output buffer.

func put(emitter *yaml_emitter_t, value byte) bool {

	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {

		return false

	}

	emitter.buffer[emitter.buffer_pos] = value

	emitter.buffer_pos++

	emitter.column++

	return true

}

// Put a line break to the output buffer.

func put_break(emitter *yaml_emitter_t) bool {

	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {

		return false

	}

	switch emitter.line_break {

	case yaml_CR_BREAK:

		emitter.buffer[emitter.buffer_pos] = '\r'

		emitter.buffer_pos += 1

	case yaml_LN_BREAK:

		emitter.buffer[emitter.buffer_pos] = '\n'

		emitter.buffer_pos += 1

	case yaml_CRLN_BREAK:

		emitter.buffer[emitter.buffer_pos+0] = '\r'

		emitter.buffer[emitter.buffer_pos+1] = '\n'

		emitter.buffer_pos += 2

	default:

		panic("unknown line break setting")

	}

	emitter.column = 0

	emitter.line++

	return true

}

// Copy a character from a string into buffer.

func write(emitter *yaml_emitter_t, s []byte, i *int) bool {

	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {

		return false

	}

	p := emitter.buffer_pos

	w := width(s[*i])

	switch w {

	case 4:

		emitter.buffer[p+3] = s[*i+3]

		fallthrough

	case 3:

		emitter.buffer[p+2] = s[*i+2]

		fallthrough

	case 2:

		emitter.buffer[p+1] = s[*i+1]

		fallthrough

	case 1:

		emitter.buffer[p+0] = s[*i+0]

	default:

		panic("unknown character width")

	}

	emitter.column++

	emitter.buffer_pos += w

	*i += w

	return true

}

// Write a whole string into buffer.

func write_all(emitter *yaml_emitter_t, s []byte) bool {

	for i := 0; i < len(s); {

		if !write(emitter, s, &i) {

			return false

		}

	}

	return true

}

// Copy a line break character from a string into buffer.

func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {

	if s[*i] == '\n' {

		if !put_break(emitter) {

			return false

		}

		*i++

	} else {

		if !write(emitter, s, i) {

			return false

		}

		emitter.column = 0

		emitter.line++

	}

	return true

}

// Set an emitter error and return false.

func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {

	emitter.error = yaml_EMITTER_ERROR

	emitter.problem = problem

	return false

}

// Emit an event.

func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	emitter.events = append(emitter.events, *event)

	for !yaml_emitter_need_more_events(emitter) {

		event := &emitter.events[emitter.events_head]

		if !yaml_emitter_analyze_event(emitter, event) {

			return false

		}

		if !yaml_emitter_state_machine(emitter, event) {

			return false

		}

		yaml_event_delete(event)

		emitter.events_head++

	}

	return true

}

// Check if we need to accumulate more events before emitting.

//

// We accumulate extra

//  - 1 event for DOCUMENT-START

//  - 2 events for SEQUENCE-START

//  - 3 events for MAPPING-START

//

func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {

	if emitter.events_head == len(emitter.events) {

		return true

	}

	var accumulate int

	switch emitter.events[emitter.events_head].typ {

	case yaml_DOCUMENT_START_EVENT:

		accumulate = 1

		break

	case yaml_SEQUENCE_START_EVENT:

		accumulate = 2

		break

	case yaml_MAPPING_START_EVENT:

		accumulate = 3

		break

	default:

		return false

	}

	if len(emitter.events)-emitter.events_head > accumulate {

		return false

	}

	var level int

	for i := emitter.events_head; i < len(emitter.events); i++ {

		switch emitter.events[i].typ {

		case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:

			level++

		case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:

			level--

		}

		if level == 0 {

			return false

		}

	}

	return true

}

// Append a directive to the directives stack.

func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool {

	for i := 0; i < len(emitter.tag_directives); i++ {

		if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {

			if allow_duplicates {

				return true

			}

			return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")

		}

	}

	// [Go] Do we actually need to copy this given garbage collection

	// and the lack of deallocating destructors?

	tag_copy := yaml_tag_directive_t{

		handle: make([]byte, len(value.handle)),

		prefix: make([]byte, len(value.prefix)),

	}

	copy(tag_copy.handle, value.handle)

	copy(tag_copy.prefix, value.prefix)

	emitter.tag_directives = append(emitter.tag_directives, tag_copy)

	return true

}

// Increase the indentation level.

func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {

	emitter.indents = append(emitter.indents, emitter.indent)

	if emitter.indent < 0 {

		if flow {

			emitter.indent = emitter.best_indent

		} else {

			emitter.indent = 0

		}

	} else if !indentless {

		emitter.indent += emitter.best_indent

	}

	return true

}

// State dispatcher.

func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	switch emitter.state {

	default:

	case yaml_EMIT_STREAM_START_STATE:

		return yaml_emitter_emit_stream_start(emitter, event)

	case yaml_EMIT_FIRST_DOCUMENT_START_STATE:

		return yaml_emitter_emit_document_start(emitter, event, true)

	case yaml_EMIT_DOCUMENT_START_STATE:

		return yaml_emitter_emit_document_start(emitter, event, false)

	case yaml_EMIT_DOCUMENT_CONTENT_STATE:

		return yaml_emitter_emit_document_content(emitter, event)

	case yaml_EMIT_DOCUMENT_END_STATE:

		return yaml_emitter_emit_document_end(emitter, event)

	case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:

		return yaml_emitter_emit_flow_sequence_item(emitter, event, true)

	case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:

		return yaml_emitter_emit_flow_sequence_item(emitter, event, false)

	case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:

		return yaml_emitter_emit_flow_mapping_key(emitter, event, true)

	case yaml_EMIT_FLOW_MAPPING_KEY_STATE:

		return yaml_emitter_emit_flow_mapping_key(emitter, event, false)

	case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:

		return yaml_emitter_emit_flow_mapping_value(emitter, event, true)

	case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:

		return yaml_emitter_emit_flow_mapping_value(emitter, event, false)

	case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:

		return yaml_emitter_emit_block_sequence_item(emitter, event, true)

	case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:

		return yaml_emitter_emit_block_sequence_item(emitter, event, false)

	case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:

		return yaml_emitter_emit_block_mapping_key(emitter, event, true)

	case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:

		return yaml_emitter_emit_block_mapping_key(emitter, event, false)

	case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:

		return yaml_emitter_emit_block_mapping_value(emitter, event, true)

	case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:

		return yaml_emitter_emit_block_mapping_value(emitter, event, false)

	case yaml_EMIT_END_STATE:

		return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")

	}

	panic("invalid emitter state")

}

// Expect STREAM-START.

func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	if event.typ != yaml_STREAM_START_EVENT {

		return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")

	}

	if emitter.encoding == yaml_ANY_ENCODING {

		emitter.encoding = event.encoding

		if emitter.encoding == yaml_ANY_ENCODING {

			emitter.encoding = yaml_UTF8_ENCODING

		}

	}

	if emitter.best_indent < 2 || emitter.best_indent > 9 {

		emitter.best_indent = 2

	}

	if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {

		emitter.best_width = 80

	}

	if emitter.best_width < 0 {

		emitter.best_width = 1<<31 - 1

	}

	if emitter.line_break == yaml_ANY_BREAK {

		emitter.line_break = yaml_LN_BREAK

	}

	emitter.indent = -1

	emitter.line = 0

	emitter.column = 0

	emitter.whitespace = true

	emitter.indention = true

	if emitter.encoding != yaml_UTF8_ENCODING {

		if !yaml_emitter_write_bom(emitter) {

			return false

		}

	}

	emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE

	return true

}

// Expect DOCUMENT-START or STREAM-END.

func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {

	if event.typ == yaml_DOCUMENT_START_EVENT {

		if event.version_directive != nil {

			if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {

				return false

			}

		}

		for i := 0; i < len(event.tag_directives); i++ {

			tag_directive := &event.tag_directives[i]

			if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {

				return false

			}

			if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {

				return false

			}

		}

		for i := 0; i < len(default_tag_directives); i++ {

			tag_directive := &default_tag_directives[i]

			if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {

				return false

			}

		}

		implicit := event.implicit

		if !first || emitter.canonical {

			implicit = false

		}

		if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) {

			if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {

				return false

			}

			if !yaml_emitter_write_indent(emitter) {

				return false

			}

		}

		if event.version_directive != nil {

			implicit = false

			if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {

				return false

			}

			if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {

				return false

			}

			if !yaml_emitter_write_indent(emitter) {

				return false

			}

		}

		if len(event.tag_directives) > 0 {

			implicit = false

			for i := 0; i < len(event.tag_directives); i++ {

				tag_directive := &event.tag_directives[i]

				if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {

					return false

				}

				if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {

					return false

				}

				if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {

					return false

				}

				if !yaml_emitter_write_indent(emitter) {

					return false

				}

			}

		}

		if yaml_emitter_check_empty_document(emitter) {

			implicit = false

		}

		if !implicit {

			if !yaml_emitter_write_indent(emitter) {

				return false

			}

			if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {

				return false

			}

			if emitter.canonical {

				if !yaml_emitter_write_indent(emitter) {

					return false

				}

			}

		}

		emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE

		return true

	}

	if event.typ == yaml_STREAM_END_EVENT {

		if emitter.open_ended {

			if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {

				return false

			}

			if !yaml_emitter_write_indent(emitter) {

				return false

			}

		}

		if !yaml_emitter_flush(emitter) {

			return false

		}

		emitter.state = yaml_EMIT_END_STATE

		return true

	}

	return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")

}

// Expect the root node.

func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)

	return yaml_emitter_emit_node(emitter, event, true, false, false, false)

}

// Expect DOCUMENT-END.

func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	if event.typ != yaml_DOCUMENT_END_EVENT {

		return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")

	}

	if !yaml_emitter_write_indent(emitter) {

		return false

	}

	if !event.implicit {

		// [Go] Allocate the slice elsewhere.

		if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {

			return false

		}

		if !yaml_emitter_write_indent(emitter) {

			return false

		}

	}

	if !yaml_emitter_flush(emitter) {

		return false

	}

	emitter.state = yaml_EMIT_DOCUMENT_START_STATE

	emitter.tag_directives = emitter.tag_directives[:0]

	return true

}

// Expect a flow item node.

func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {

	if first {

		if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {

			return false

		}

		if !yaml_emitter_increase_indent(emitter, true, false) {

			return false

		}

		emitter.flow_level++

	}

	if event.typ == yaml_SEQUENCE_END_EVENT {

		emitter.flow_level--

		emitter.indent = emitter.indents[len(emitter.indents)-1]

		emitter.indents = emitter.indents[:len(emitter.indents)-1]

		if emitter.canonical && !first {

			if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {

				return false

			}

			if !yaml_emitter_write_indent(emitter) {

				return false

			}

		}

		if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {

			return false

		}

		emitter.state = emitter.states[len(emitter.states)-1]

		emitter.states = emitter.states[:len(emitter.states)-1]

		return true

	}

	if !first {

		if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {

			return false

		}

	}

	if emitter.canonical || emitter.column > emitter.best_width {

		if !yaml_emitter_write_indent(emitter) {

			return false

		}

	}

	emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)

	return yaml_emitter_emit_node(emitter, event, false, true, false, false)

}

// Expect a flow key node.

func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {

	if first {

		if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {

			return false

		}

		if !yaml_emitter_increase_indent(emitter, true, false) {

			return false

		}

		emitter.flow_level++

	}

	if event.typ == yaml_MAPPING_END_EVENT {

		emitter.flow_level--

		emitter.indent = emitter.indents[len(emitter.indents)-1]

		emitter.indents = emitter.indents[:len(emitter.indents)-1]

		if emitter.canonical && !first {

			if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {

				return false

			}

			if !yaml_emitter_write_indent(emitter) {

				return false

			}

		}

		if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {

			return false

		}

		emitter.state = emitter.states[len(emitter.states)-1]

		emitter.states = emitter.states[:len(emitter.states)-1]

		return true

	}

	if !first {

		if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {

			return false

		}

	}

	if emitter.canonical || emitter.column > emitter.best_width {

		if !yaml_emitter_write_indent(emitter) {

			return false

		}

	}

	if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {

		emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)

		return yaml_emitter_emit_node(emitter, event, false, false, true, true)

	}

	if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {

		return false

	}

	emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)

	return yaml_emitter_emit_node(emitter, event, false, false, true, false)

}

// Expect a flow value node.

func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {

	if simple {

		if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {

			return false

		}

	} else {

		if emitter.canonical || emitter.column > emitter.best_width {

			if !yaml_emitter_write_indent(emitter) {

				return false

			}

		}

		if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {

			return false

		}

	}

	emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)

	return yaml_emitter_emit_node(emitter, event, false, false, true, false)

}

// Expect a block item node.

func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {

	if first {

		if !yaml_emitter_increase_indent(emitter, false, emitter.mapping_context && !emitter.indention) {

			return false

		}

	}

	if event.typ == yaml_SEQUENCE_END_EVENT {

		emitter.indent = emitter.indents[len(emitter.indents)-1]

		emitter.indents = emitter.indents[:len(emitter.indents)-1]

		emitter.state = emitter.states[len(emitter.states)-1]

		emitter.states = emitter.states[:len(emitter.states)-1]

		return true

	}

	if !yaml_emitter_write_indent(emitter) {

		return false

	}

	if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {

		return false

	}

	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)

	return yaml_emitter_emit_node(emitter, event, false, true, false, false)

}

// Expect a block key node.

func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {

	if first {

		if !yaml_emitter_increase_indent(emitter, false, false) {

			return false

		}

	}

	if event.typ == yaml_MAPPING_END_EVENT {

		emitter.indent = emitter.indents[len(emitter.indents)-1]

		emitter.indents = emitter.indents[:len(emitter.indents)-1]

		emitter.state = emitter.states[len(emitter.states)-1]

		emitter.states = emitter.states[:len(emitter.states)-1]

		return true

	}

	if !yaml_emitter_write_indent(emitter) {

		return false

	}

	if yaml_emitter_check_simple_key(emitter) {

		emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)

		return yaml_emitter_emit_node(emitter, event, false, false, true, true)

	}

	if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {

		return false

	}

	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)

	return yaml_emitter_emit_node(emitter, event, false, false, true, false)

}

// Expect a block value node.

func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {

	if simple {

		if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {

			return false

		}

	} else {

		if !yaml_emitter_write_indent(emitter) {

			return false

		}

		if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {

			return false

		}

	}

	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)

	return yaml_emitter_emit_node(emitter, event, false, false, true, false)

}

// Expect a node.

func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t,

	root bool, sequence bool, mapping bool, simple_key bool) bool {

	emitter.root_context = root

	emitter.sequence_context = sequence

	emitter.mapping_context = mapping

	emitter.simple_key_context = simple_key

	switch event.typ {

	case yaml_ALIAS_EVENT:

		return yaml_emitter_emit_alias(emitter, event)

	case yaml_SCALAR_EVENT:

		return yaml_emitter_emit_scalar(emitter, event)

	case yaml_SEQUENCE_START_EVENT:

		return yaml_emitter_emit_sequence_start(emitter, event)

	case yaml_MAPPING_START_EVENT:

		return yaml_emitter_emit_mapping_start(emitter, event)

	default:

		return yaml_emitter_set_emitter_error(emitter,

			fmt.Sprintf("expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, but got %v", event.typ))

	}

}

// Expect ALIAS.

func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	if !yaml_emitter_process_anchor(emitter) {

		return false

	}

	emitter.state = emitter.states[len(emitter.states)-1]

	emitter.states = emitter.states[:len(emitter.states)-1]

	return true

}

// Expect SCALAR.

func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	if !yaml_emitter_select_scalar_style(emitter, event) {

		return false

	}

	if !yaml_emitter_process_anchor(emitter) {

		return false

	}

	if !yaml_emitter_process_tag(emitter) {

		return false

	}

	if !yaml_emitter_increase_indent(emitter, true, false) {

		return false

	}

	if !yaml_emitter_process_scalar(emitter) {

		return false

	}

	emitter.indent = emitter.indents[len(emitter.indents)-1]

	emitter.indents = emitter.indents[:len(emitter.indents)-1]

	emitter.state = emitter.states[len(emitter.states)-1]

	emitter.states = emitter.states[:len(emitter.states)-1]

	return true

}

// Expect SEQUENCE-START.

func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	if !yaml_emitter_process_anchor(emitter) {

		return false

	}

	if !yaml_emitter_process_tag(emitter) {

		return false

	}

	if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE ||

		yaml_emitter_check_empty_sequence(emitter) {

		emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE

	} else {

		emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE

	}

	return true

}

// Expect MAPPING-START.

func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	if !yaml_emitter_process_anchor(emitter) {

		return false

	}

	if !yaml_emitter_process_tag(emitter) {

		return false

	}

	if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE ||

		yaml_emitter_check_empty_mapping(emitter) {

		emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE

	} else {

		emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE

	}

	return true

}

// Check if the document content is an empty scalar.

func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {

	return false // [Go] Huh?

}

// Check if the next events represent an empty sequence.

func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {

	if len(emitter.events)-emitter.events_head < 2 {

		return false

	}

	return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&

		emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT

}

// Check if the next events represent an empty mapping.

func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {

	if len(emitter.events)-emitter.events_head < 2 {

		return false

	}

	return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&

		emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT

}

// Check if the next node can be expressed as a simple key.

func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {

	length := 0

	switch emitter.events[emitter.events_head].typ {

	case yaml_ALIAS_EVENT:

		length += len(emitter.anchor_data.anchor)

	case yaml_SCALAR_EVENT:

		if emitter.scalar_data.multiline {

			return false

		}

		length += len(emitter.anchor_data.anchor) +

			len(emitter.tag_data.handle) +

			len(emitter.tag_data.suffix) +

			len(emitter.scalar_data.value)

	case yaml_SEQUENCE_START_EVENT:

		if !yaml_emitter_check_empty_sequence(emitter) {

			return false

		}

		length += len(emitter.anchor_data.anchor) +

			len(emitter.tag_data.handle) +

			len(emitter.tag_data.suffix)

	case yaml_MAPPING_START_EVENT:

		if !yaml_emitter_check_empty_mapping(emitter) {

			return false

		}

		length += len(emitter.anchor_data.anchor) +

			len(emitter.tag_data.handle) +

			len(emitter.tag_data.suffix)

	default:

		return false

	}

	return length <= 128

}

// Determine an acceptable scalar style.

func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool {

	no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0

	if no_tag && !event.implicit && !event.quoted_implicit {

		return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")

	}

	style := event.scalar_style()

	if style == yaml_ANY_SCALAR_STYLE {

		style = yaml_PLAIN_SCALAR_STYLE

	}

	if emitter.canonical {

		style = yaml_DOUBLE_QUOTED_SCALAR_STYLE

	}

	if emitter.simple_key_context && emitter.scalar_data.multiline {

		style = yaml_DOUBLE_QUOTED_SCALAR_STYLE

	}

	if style == yaml_PLAIN_SCALAR_STYLE {

		if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed ||

			emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {

			style = yaml_SINGLE_QUOTED_SCALAR_STYLE

		}

		if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) {

			style = yaml_SINGLE_QUOTED_SCALAR_STYLE

		}

		if no_tag && !event.implicit {

			style = yaml_SINGLE_QUOTED_SCALAR_STYLE

		}

	}

	if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {

		if !emitter.scalar_data.single_quoted_allowed {

			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE

		}

	}

	if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE {

		if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context {

			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE

		}

	}

	if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {

		emitter.tag_data.handle = []byte{'!'}

	}

	emitter.scalar_data.style = style

	return true

}

// Write an anchor.

func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {

	if emitter.anchor_data.anchor == nil {

		return true

	}

	c := []byte{'&'}

	if emitter.anchor_data.alias {

		c[0] = '*'

	}

	if !yaml_emitter_write_indicator(emitter, c, true, false, false) {

		return false

	}

	return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)

}

// Write a tag.

func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {

	if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {

		return true

	}

	if len(emitter.tag_data.handle) > 0 {

		if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {

			return false

		}

		if len(emitter.tag_data.suffix) > 0 {

			if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {

				return false

			}

		}

	} else {

		// [Go] Allocate these slices elsewhere.

		if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {

			return false

		}