/**

  * Copyright (c) 2008-2011, http://www.snakeyaml.org

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.yaml.snakeyaml.emitter;

 import java.io.IOException;

 import java.io.Writer;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 import java.util.Map;

 import java.util.Queue;

 import java.util.Set;

 import java.util.TreeSet;

 import java.util.concurrent.ArrayBlockingQueue;

 import java.util.regex.Pattern;

 import org.yaml.snakeyaml.DumperOptions;

 import org.yaml.snakeyaml.DumperOptions.ScalarStyle;

 import org.yaml.snakeyaml.events.AliasEvent;

 import org.yaml.snakeyaml.events.CollectionEndEvent;

 import org.yaml.snakeyaml.events.CollectionStartEvent;

 import org.yaml.snakeyaml.events.DocumentEndEvent;

 import org.yaml.snakeyaml.events.DocumentStartEvent;

 import org.yaml.snakeyaml.events.Event;

 import org.yaml.snakeyaml.events.MappingEndEvent;

 import org.yaml.snakeyaml.events.MappingStartEvent;

 import org.yaml.snakeyaml.events.NodeEvent;

 import org.yaml.snakeyaml.events.ScalarEvent;

 import org.yaml.snakeyaml.events.SequenceEndEvent;

 import org.yaml.snakeyaml.events.SequenceStartEvent;

 import org.yaml.snakeyaml.events.StreamEndEvent;

 import org.yaml.snakeyaml.events.StreamStartEvent;

 import org.yaml.snakeyaml.nodes.Tag;

 import org.yaml.snakeyaml.scanner.Constant;

 import org.yaml.snakeyaml.util.ArrayStack;

 /**

  * <pre>

  * Emitter expects events obeying the following grammar:

  * stream ::= STREAM-START document* STREAM-END

  * document ::= DOCUMENT-START node DOCUMENT-END

  * node ::= SCALAR | sequence | mapping

  * sequence ::= SEQUENCE-START node* SEQUENCE-END

  * mapping ::= MAPPING-START (node node)* MAPPING-END

  * </pre>

  */

 public final class Emitter implements Emitable {

     private static final Map<Character, String> ESCAPE_REPLACEMENTS = new HashMap<Character, String>();

     public static final int MIN_INDENT = 1;

     public static final int MAX_INDENT = 10;

     public static final char[] SPACE = { ' ' };

     static {

         ESCAPE_REPLACEMENTS.put(new Character('\0'), "0");

         ESCAPE_REPLACEMENTS.put(new Character('\u0007'), "a");

         ESCAPE_REPLACEMENTS.put(new Character('\u0008'), "b");

         ESCAPE_REPLACEMENTS.put(new Character('\u0009'), "t");

         ESCAPE_REPLACEMENTS.put(new Character('\n'), "n");

         ESCAPE_REPLACEMENTS.put(new Character('\u000B'), "v");

         ESCAPE_REPLACEMENTS.put(new Character('\u000C'), "f");

         ESCAPE_REPLACEMENTS.put(new Character('\r'), "r");

         ESCAPE_REPLACEMENTS.put(new Character('\u001B'), "e");

         ESCAPE_REPLACEMENTS.put(new Character('"'), "\"");

         ESCAPE_REPLACEMENTS.put(new Character('\\'), "\\");

         ESCAPE_REPLACEMENTS.put(new Character('\u0085'), "N");

         ESCAPE_REPLACEMENTS.put(new Character('\u00A0'), "_");

         ESCAPE_REPLACEMENTS.put(new Character('\u2028'), "L");

         ESCAPE_REPLACEMENTS.put(new Character('\u2029'), "P");

     }

     private final static Map<String, String> DEFAULT_TAG_PREFIXES = new LinkedHashMap<String, String>();

     static {

         DEFAULT_TAG_PREFIXES.put("!", "!");

         DEFAULT_TAG_PREFIXES.put(Tag.PREFIX, "!!");

     }

     // The stream should have the methods `write` and possibly `flush`.

     private final Writer stream;

     // Encoding is defined by Writer (cannot be overriden by STREAM-START.)

     // private Charset encoding;

     // Emitter is a state machine with a stack of states to handle nested

     // structures.

     private final ArrayStack<EmitterState> states;

     private EmitterState state;

     // Current event and the event queue.

     private final Queue<Event> events;

     private Event event;

     // The current indentation level and the stack of previous indents.

     private final ArrayStack<Integer> indents;

     private Integer indent;

     // Flow level.

     private int flowLevel;

     // Contexts.

     private boolean rootContext;

     private boolean mappingContext;

     private boolean simpleKeyContext;

     //

     // Characteristics of the last emitted character:

     // - current position.

     // - is it a whitespace?

     // - is it an indention character

     // (indentation space, '-', '?', or ':')?

     // private int line; this variable is not used

     private int column;

     private boolean whitespace;

     private boolean indention;

     private boolean openEnded;

     // Formatting details.

     private Boolean canonical;

     // pretty print flow by adding extra line breaks

     private Boolean prettyFlow;

     private boolean allowUnicode;

     private int bestIndent;

     private int bestWidth;

     private char[] bestLineBreak;

     // Tag prefixes.

     private Map<String, String> tagPrefixes;

     // Prepared anchor and tag.

     private String preparedAnchor;

     private String preparedTag;

     // Scalar analysis and style.

     private ScalarAnalysis analysis;

     private Character style;

     private DumperOptions options;

     public Emitter(Writer stream, DumperOptions opts) {

         // The stream should have the methods `write` and possibly `flush`.

         this.stream = stream;

         // Emitter is a state machine with a stack of states to handle nested

         // structures.

         this.states = new ArrayStack<EmitterState>(100);

         this.state = new ExpectStreamStart();

         // Current event and the event queue.

         this.events = new ArrayBlockingQueue<Event>(100);

         this.event = null;

         // The current indentation level and the stack of previous indents.

         this.indents = new ArrayStack<Integer>(10);

         this.indent = null;

         // Flow level.

         this.flowLevel = 0;

         // Contexts.

         mappingContext = false;

         simpleKeyContext = false;

         //

         // Characteristics of the last emitted character:

         // - current position.

         // - is it a whitespace?

         // - is it an indention character

         // (indentation space, '-', '?', or ':')?

         column = 0;

         whitespace = true;

         indention = true;

         // Whether the document requires an explicit document indicator

         openEnded = false;

         // Formatting details.

         this.canonical = opts.isCanonical();

         this.prettyFlow = opts.isPrettyFlow();

         this.allowUnicode = opts.isAllowUnicode();

         this.bestIndent = 2;

         if ((opts.getIndent() > MIN_INDENT) && (opts.getIndent() < MAX_INDENT)) {

             this.bestIndent = opts.getIndent();

         }

         this.bestWidth = 80;

         if (opts.getWidth() > this.bestIndent * 2) {

             this.bestWidth = opts.getWidth();

         }

         this.bestLineBreak = opts.getLineBreak().getString().toCharArray();

         // Tag prefixes.

         this.tagPrefixes = new LinkedHashMap<String, String>();

         // Prepared anchor and tag.

         this.preparedAnchor = null;

         this.preparedTag = null;

         // Scalar analysis and style.

         this.analysis = null;

         this.style = null;

         this.options = opts;

     }

     public void emit(Event event) throws IOException {

         this.events.add(event);

         while (!needMoreEvents()) {

             this.event = this.events.poll();

             this.state.expect();

             this.event = null;

         }

     }

     // In some cases, we wait for a few next events before emitting.

     private boolean needMoreEvents() {

         if (events.isEmpty()) {

             return true;

         }

         Event event = events.peek();

         if (event instanceof DocumentStartEvent) {

             return needEvents(1);

         } else if (event instanceof SequenceStartEvent) {

             return needEvents(2);

         } else if (event instanceof MappingStartEvent) {

             return needEvents(3);

         } else {

             return false;

         }

     }

     private boolean needEvents(int count) {

         int level = 0;

         Iterator<Event> iter = events.iterator();

         iter.next();

         while (iter.hasNext()) {

             Event event = iter.next();

             if (event instanceof DocumentStartEvent || event instanceof CollectionStartEvent) {

                 level++;

             } else if (event instanceof DocumentEndEvent || event instanceof CollectionEndEvent) {

                 level--;

             } else if (event instanceof StreamEndEvent) {

                 level = -1;

             }

             if (level < 0) {

                 return false;

             }

         }

         return events.size() < count + 1;

     }

     private void increaseIndent(boolean flow, boolean indentless) {

         indents.push(indent);

         if (indent == null) {

             if (flow) {

                 indent = bestIndent;

             } else {

                 indent = 0;

             }

         } else if (!indentless) {

             this.indent += bestIndent;

         }

     }

     // States

     // Stream handlers.

     private class ExpectStreamStart implements EmitterState {

         public void expect() throws IOException {

             if (event instanceof StreamStartEvent) {

                 writeStreamStart();

                 state = new ExpectFirstDocumentStart();

             } else {

                 throw new EmitterException("expected StreamStartEvent, but got " + event);

             }

         }

     }

     private class ExpectNothing implements EmitterState {

         public void expect() throws IOException {

             throw new EmitterException("expecting nothing, but got " + event);

         }

     }

     // Document handlers.

     private class ExpectFirstDocumentStart implements EmitterState {

         public void expect() throws IOException {

             new ExpectDocumentStart(true).expect();

         }

     }

     private class ExpectDocumentStart implements EmitterState {

         private boolean first;

         public ExpectDocumentStart(boolean first) {

             this.first = first;

         }

         public void expect() throws IOException {

             if (event instanceof DocumentStartEvent) {

                 DocumentStartEvent ev = (DocumentStartEvent) event;

                 if ((ev.getVersion() != null || ev.getTags() != null) && openEnded) {

                     writeIndicator("...", true, false, false);

                     writeIndent();

                 }

                 if (ev.getVersion() != null) {

                     String versionText = prepareVersion(ev.getVersion());

                     writeVersionDirective(versionText);

                 }

                 tagPrefixes = new LinkedHashMap<String, String>(DEFAULT_TAG_PREFIXES);

                 if (ev.getTags() != null) {

                     Set<String> handles = new TreeSet<String>(ev.getTags().keySet());

                     for (String handle : handles) {

                         String prefix = ev.getTags().get(handle);

                         tagPrefixes.put(prefix, handle);

                         String handleText = prepareTagHandle(handle);

                         String prefixText = prepareTagPrefix(prefix);

                         writeTagDirective(handleText, prefixText);

                     }

                 }

                 boolean implicit = first && !ev.getExplicit() && !canonical

                         && ev.getVersion() == null && ev.getTags() == null && !checkEmptyDocument();

                 if (!implicit) {

                     writeIndent();

                     writeIndicator("---", true, false, false);

                     if (canonical) {

                         writeIndent();

                     }

                 }

                 state = new ExpectDocumentRoot();

             } else if (event instanceof StreamEndEvent) {

                 // TODO fix 313 PyYAML changeset

                 // if (openEnded) {

                 // writeIndicator("...", true, false, false);

                 // writeIndent();

                 // }

                 writeStreamEnd();

                 state = new ExpectNothing();

             } else {

                 throw new EmitterException("expected DocumentStartEvent, but got " + event);

             }

         }

     }

     private class ExpectDocumentEnd implements EmitterState {

         public void expect() throws IOException {

             if (event instanceof DocumentEndEvent) {

                 writeIndent();

                 if (((DocumentEndEvent) event).getExplicit()) {

                     writeIndicator("...", true, false, false);

                     writeIndent();

                 }

                 flushStream();

                 state = new ExpectDocumentStart(false);

             } else {

                 throw new EmitterException("expected DocumentEndEvent, but got " + event);

             }

         }

     }

     private class ExpectDocumentRoot implements EmitterState {

         public void expect() throws IOException {

             states.push(new ExpectDocumentEnd());

             expectNode(true, false, false, false);

         }

     }

     // Node handlers.

     private void expectNode(boolean root, boolean sequence, boolean mapping, boolean simpleKey)

             throws IOException {

         rootContext = root;

         mappingContext = mapping;

         simpleKeyContext = simpleKey;

         if (event instanceof AliasEvent) {

             expectAlias();

         } else if (event instanceof ScalarEvent || event instanceof CollectionStartEvent) {

             processAnchor("&");

             processTag();

             if (event instanceof ScalarEvent) {

                 expectScalar();

             } else if (event instanceof SequenceStartEvent) {

                 if (flowLevel != 0 || canonical || ((SequenceStartEvent) event).getFlowStyle()

                         || checkEmptySequence()) {

                     expectFlowSequence();

                 } else {

                     expectBlockSequence();

                 }

             } else {// MappingStartEvent

                 if (flowLevel != 0 || canonical || ((MappingStartEvent) event).getFlowStyle()

                         || checkEmptyMapping()) {

                     expectFlowMapping();

                 } else {

                     expectBlockMapping();

                 }

             }

         } else {

             throw new EmitterException("expected NodeEvent, but got " + event);

         }

     }

     private void expectAlias() throws IOException {

         if (((NodeEvent) event).getAnchor() == null) {

             throw new EmitterException("anchor is not specified for alias");

         }

         processAnchor("*");

         state = states.pop();

     }

     private void expectScalar() throws IOException {

         increaseIndent(true, false);

         processScalar();

         indent = indents.pop();

         state = states.pop();

     }

     // Flow sequence handlers.

     private void expectFlowSequence() throws IOException {

         writeIndicator("[", true, true, false);

         flowLevel++;

         increaseIndent(true, false);

         if (prettyFlow) {

             writeIndent();

         }

         state = new ExpectFirstFlowSequenceItem();

     }

     private class ExpectFirstFlowSequenceItem implements EmitterState {

         public void expect() throws IOException {

             if (event instanceof SequenceEndEvent) {

                 indent = indents.pop();

                 flowLevel--;

                 writeIndicator("]", false, false, false);

                 state = states.pop();

             } else {

                 if (canonical || column > bestWidth || prettyFlow) {

                     writeIndent();

                 }

                 states.push(new ExpectFlowSequenceItem());

                 expectNode(false, true, false, false);

             }

         }

     }

     private class ExpectFlowSequenceItem implements EmitterState {

         public void expect() throws IOException {

             if (event instanceof SequenceEndEvent) {

                 indent = indents.pop();

                 flowLevel--;

                 if (canonical) {

                     writeIndicator(",", false, false, false);

                     writeIndent();

                 }

                 writeIndicator("]", false, false, false);

                 if (prettyFlow) {

                     writeIndent();

                 }

                 state = states.pop();

             } else {

                 writeIndicator(",", false, false, false);

                 if (canonical || column > bestWidth || prettyFlow) {

                     writeIndent();

                 }

                 states.push(new ExpectFlowSequenceItem());

                 expectNode(false, true, false, false);

             }

         }

     }

     // Flow mapping handlers.

     private void expectFlowMapping() throws IOException {

         writeIndicator("{", true, true, false);

         flowLevel++;

         increaseIndent(true, false);

         if (prettyFlow) {

             writeIndent();

         }

         state = new ExpectFirstFlowMappingKey();

     }

     private class ExpectFirstFlowMappingKey implements EmitterState {

         public void expect() throws IOException {

             if (event instanceof MappingEndEvent) {

                 indent = indents.pop();

                 flowLevel--;

                 writeIndicator("}", false, false, false);

                 state = states.pop();

             } else {

                 if (canonical || column > bestWidth || prettyFlow) {

                     writeIndent();

                 }

                 if (!canonical && checkSimpleKey()) {

                     states.push(new ExpectFlowMappingSimpleValue());

                     expectNode(false, false, true, true);

                 } else {

                     writeIndicator("?", true, false, false);

                     states.push(new ExpectFlowMappingValue());

                     expectNode(false, false, true, false);

                 }

             }

         }

     }

     private class ExpectFlowMappingKey implements EmitterState {

         public void expect() throws IOException {

             if (event instanceof MappingEndEvent) {

                 indent = indents.pop();

                 flowLevel--;

                 if (canonical) {

                     writeIndicator(",", false, false, false);

                     writeIndent();

                 }

                 if (prettyFlow) {

                     writeIndent();

                 }

                 writeIndicator("}", false, false, false);

                 state = states.pop();

             } else {

                 writeIndicator(",", false, false, false);

                 if (canonical || column > bestWidth || prettyFlow) {

                     writeIndent();

                 }

                 if (!canonical && checkSimpleKey()) {

                     states.push(new ExpectFlowMappingSimpleValue());

                     expectNode(false, false, true, true);

                 } else {

                     writeIndicator("?", true, false, false);

                     states.push(new ExpectFlowMappingValue());

                     expectNode(false, false, true, false);

                 }

             }

         }

     }

     private class ExpectFlowMappingSimpleValue implements EmitterState {

         public void expect() throws IOException {

             writeIndicator(":", false, false, false);

             states.push(new ExpectFlowMappingKey());

             expectNode(false, false, true, false);

         }

     }

     private class ExpectFlowMappingValue implements EmitterState {

         public void expect() throws IOException {

             if (canonical || column > bestWidth || prettyFlow) {

                 writeIndent();

             }

             writeIndicator(":", true, false, false);

             states.push(new ExpectFlowMappingKey());

             expectNode(false, false, true, false);

         }

     }

     // Block sequence handlers.

     private void expectBlockSequence() throws IOException {

         boolean indentless = (mappingContext && !indention);

         increaseIndent(false, indentless);

         state = new ExpectFirstBlockSequenceItem();

     }

     private class ExpectFirstBlockSequenceItem implements EmitterState {

         public void expect() throws IOException {

             new ExpectBlockSequenceItem(true).expect();

         }

     }

     private class ExpectBlockSequenceItem implements EmitterState {

         private boolean first;

         public ExpectBlockSequenceItem(boolean first) {

             this.first = first;

         }

         public void expect() throws IOException {

             if (!this.first && event instanceof SequenceEndEvent) {

                 indent = indents.pop();

                 state = states.pop();

             } else {

                 writeIndent();

                 writeIndicator("-", true, false, true);

                 states.push(new ExpectBlockSequenceItem(false));

                 expectNode(false, true, false, false);

             }

         }

     }

     // Block mapping handlers.

     private void expectBlockMapping() throws IOException {

         increaseIndent(false, false);

         state = new ExpectFirstBlockMappingKey();

     }

     private class ExpectFirstBlockMappingKey implements EmitterState {

         public void expect() throws IOException {

             new ExpectBlockMappingKey(true).expect();

         }

     }

     private class ExpectBlockMappingKey implements EmitterState {

         private boolean first;

         public ExpectBlockMappingKey(boolean first) {

             this.first = first;

         }

         public void expect() throws IOException {

             if (!this.first && event instanceof MappingEndEvent) {

                 indent = indents.pop();

                 state = states.pop();

             } else {

                 writeIndent();

                 if (checkSimpleKey()) {

                     states.push(new ExpectBlockMappingSimpleValue());

                     expectNode(false, false, true, true);

                 } else {

                     writeIndicator("?", true, false, true);

                     states.push(new ExpectBlockMappingValue());

                     expectNode(false, false, true, false);

                 }

             }

         }

     }

     private class ExpectBlockMappingSimpleValue implements EmitterState {

         public void expect() throws IOException {

             writeIndicator(":", false, false, false);

             states.push(new ExpectBlockMappingKey(false));

             expectNode(false, false, true, false);

         }

     }

     private class ExpectBlockMappingValue implements EmitterState {

         public void expect() throws IOException {

             writeIndent();

             writeIndicator(":", true, false, true);

             states.push(new ExpectBlockMappingKey(false));

             expectNode(false, false, true, false);

         }

     }

     // Checkers.

     private boolean checkEmptySequence() {

         return (event instanceof SequenceStartEvent && !events.isEmpty() && events.peek() instanceof SequenceEndEvent);

     }

     private boolean checkEmptyMapping() {

         return (event instanceof MappingStartEvent && !events.isEmpty() && events.peek() instanceof MappingEndEvent);

     }

     private boolean checkEmptyDocument() {

         if (!(event instanceof DocumentStartEvent) || events.isEmpty()) {

             return false;

         }

         Event event = events.peek();

         if (event instanceof ScalarEvent) {

             ScalarEvent e = (ScalarEvent) event;

             return (e.getAnchor() == null && e.getTag() == null && e.getImplicit() != null && e

                     .getValue() == "");

         }

         return false;

     }

     private boolean checkSimpleKey() {

         int length = 0;

         if (event instanceof NodeEvent && ((NodeEvent) event).getAnchor() != null) {

             if (preparedAnchor == null) {

                 preparedAnchor = prepareAnchor(((NodeEvent) event).getAnchor());

             }

             length += preparedAnchor.length();

         }

         String tag = null;

         if (event instanceof ScalarEvent) {

             tag = ((ScalarEvent) event).getTag();

         } else if (event instanceof CollectionStartEvent) {

             tag = ((CollectionStartEvent) event).getTag();

         }

         if (tag != null) {

             if (preparedTag == null) {

                 preparedTag = prepareTag(tag);

             }

             length += preparedTag.length();

         }

         if (event instanceof ScalarEvent) {

             if (analysis == null) {

                 analysis = analyzeScalar(((ScalarEvent) event).getValue());

             }

             length += analysis.scalar.length();

         }

         return (length < 128 && (event instanceof AliasEvent

                 || (event instanceof ScalarEvent && !analysis.empty && !analysis.multiline)

                 || checkEmptySequence() || checkEmptyMapping()));

     }

     // Anchor, Tag, and Scalar processors.

     private void processAnchor(String indicator) throws IOException {

         NodeEvent ev = (NodeEvent) event;

         if (ev.getAnchor() == null) {

             preparedAnchor = null;

             return;

         }

         if (preparedAnchor == null) {

             preparedAnchor = prepareAnchor(ev.getAnchor());

         }

         writeIndicator(indicator + preparedAnchor, true, false, false);

         preparedAnchor = null;

     }

     private void processTag() throws IOException {

         String tag = null;

         if (event instanceof ScalarEvent) {

             ScalarEvent ev = (ScalarEvent) event;

             tag = ev.getTag();

             if (style == null) {

                 style = chooseScalarStyle();

             }

             if (((!canonical || tag == null) && ((style == null && ev.getImplicit()

                     .canOmitTagInPlainScalar()) || (style != null && ev.getImplicit()

                     .canOmitTagInNonPlainScalar())))) {

                 preparedTag = null;

                 return;

             }

             if (ev.getImplicit().canOmitTagInPlainScalar() && tag == null) {

                 tag = "!";

                 preparedTag = null;

             }

         } else {

             CollectionStartEvent ev = (CollectionStartEvent) event;

             tag = ev.getTag();

             if ((!canonical || tag == null) && ev.getImplicit()) {

                 preparedTag = null;

                 return;

             }

         }

         if (tag == null) {

             throw new EmitterException("tag is not specified");

         }

         if (preparedTag == null) {

             preparedTag = prepareTag(tag);

         }

         writeIndicator(preparedTag, true, false, false);

         preparedTag = null;

     }

     private Character chooseScalarStyle() {

         ScalarEvent ev = (ScalarEvent) event;

         if (analysis == null) {

             analysis = analyzeScalar(ev.getValue());

         }

         if (ev.getStyle() != null && ev.getStyle() == '"' || this.canonical) {

             return '"';

         }

         if (ev.getStyle() == null && ev.getImplicit().canOmitTagInPlainScalar()) {

             if (!(simpleKeyContext && (analysis.empty || analysis.multiline))

                     && ((flowLevel != 0 && analysis.allowFlowPlain) || (flowLevel == 0 && analysis.allowBlockPlain))) {

                 return null;

             }

         }

         if (ev.getStyle() != null && (ev.getStyle() == '|' || ev.getStyle() == '>')) {

             if (flowLevel == 0 && !simpleKeyContext && analysis.allowBlock) {

                 return ev.getStyle();

             }

         }

         if (ev.getStyle() == null || ev.getStyle() == '\'') {

             if (analysis.allowSingleQuoted && !(simpleKeyContext && analysis.multiline)) {

                 return '\'';

             }

         }

         return '"';

     }

     private void processScalar() throws IOException {

         ScalarEvent ev = (ScalarEvent) event;

         if (analysis == null) {

             analysis = analyzeScalar(ev.getValue());

         }

         if (style == null) {

             style = chooseScalarStyle();

         }

         style = options.calculateScalarStyle(analysis, ScalarStyle.createStyle(style)).getChar();

         boolean split = !simpleKeyContext;

         if (style == null) {

             writePlain(analysis.scalar, split);

         } else {

             switch (style) {

             case '"':

                 writeDoubleQuoted(analysis.scalar, split);

                 break;

             case '\'':

                 writeSingleQuoted(analysis.scalar, split);

                 break;

             case '>':

                 writeFolded(analysis.scalar);

                 break;

             case '|':

                 writeLiteral(analysis.scalar);

                 break;

             }

         }

         analysis = null;

         style = null;

     }

     // Analyzers.

     private String prepareVersion(Integer[] version) {

         Integer major = version[0];

         Integer minor = version[1];

         if (major != 1) {

             throw new EmitterException("unsupported YAML version: " + version[0] + "." + version[1]);

         }

         return major.toString() + "." + minor.toString();

     }

     private final static Pattern HANDLE_FORMAT = Pattern.compile("^![-_\\w]*!$");

     private String prepareTagHandle(String handle) {

         if (handle.length() == 0) {

             throw new EmitterException("tag handle must not be empty");

         } else if (handle.charAt(0) != '!' || handle.charAt(handle.length() - 1) != '!') {

             throw new EmitterException("tag handle must start and end with '!': " + handle);

         } else if (!"!".equals(handle) && !HANDLE_FORMAT.matcher(handle).matches()) {

             throw new EmitterException("invalid character in the tag handle: " + handle);

         }

         return handle;

     }

     private String prepareTagPrefix(String prefix) {

         if (prefix.length() == 0) {

             throw new EmitterException("tag prefix must not be empty");

         }

         StringBuilder chunks = new StringBuilder();

         int start = 0;

         int end = 0;

         if (prefix.charAt(0) == '!') {

             end = 1;

         }

         while (end < prefix.length()) {

             end++;

         }

         if (start < end) {

             chunks.append(prefix.substring(start, end));

         }

         return chunks.toString();

     }

     private String prepareTag(String tag) {

         if (tag.length() == 0) {

             throw new EmitterException("tag must not be empty");

         }

         if ("!".equals(tag)) {

             return tag;

         }

         String handle = null;

         String suffix = tag;

         for (String prefix : tagPrefixes.keySet()) {

             if (tag.startsWith(prefix) && ("!".equals(prefix) || prefix.length() < tag.length())) {

                 handle = prefix;

             }

         }

         if (handle != null) {

             suffix = tag.substring(handle.length());

             handle = tagPrefixes.get(handle);

         }

         int end = suffix.length();

         String suffixText = end > 0 ? suffix.substring(0, end) : "";

         if (handle != null) {

             return handle + suffixText;

         }

         return "!<" + suffixText + ">";

     }

     private final static Pattern ANCHOR_FORMAT = Pattern.compile("^[-_\\w]*$");

     static String prepareAnchor(String anchor) {

         if (anchor.length() == 0) {

             throw new EmitterException("anchor must not be empty");

         }

         if (!ANCHOR_FORMAT.matcher(anchor).matches()) {

             throw new EmitterException("invalid character in the anchor: " + anchor);

         }

         return anchor;

     }

     private ScalarAnalysis analyzeScalar(String scalar) {

         // Empty scalar is a special case.

         if (scalar.length() == 0) {

             return new ScalarAnalysis(scalar, true, false, false, true, true, true, false);

         }

         // Indicators and special characters.

         boolean blockIndicators = false;

         boolean flowIndicators = false;

         boolean lineBreaks = false;

         boolean specialCharacters = false;

         // Important whitespace combinations.

         boolean leadingSpace = false;

         boolean leadingBreak = false;

         boolean trailingSpace = false;

         boolean trailingBreak = false;

         boolean breakSpace = false;

         boolean spaceBreak = false;

         // Check document indicators.

         if (scalar.startsWith("---") || scalar.startsWith("...")) {

             blockIndicators = true;

             flowIndicators = true;

         }

         // First character or preceded by a whitespace.

         boolean preceededByWhitespace = true;

         boolean followedByWhitespace = (scalar.length() == 1 || Constant.NULL_BL_T_LINEBR

                 .has(scalar.charAt(1)));

         // The previous character is a space.

         boolean previousSpace = false;

         // The previous character is a break.

         boolean previousBreak = false;

         int index = 0;

         while (index < scalar.length()) {

             char ch = scalar.charAt(index);

             // Check for indicators.

             if (index == 0) {

                 // Leading indicators are special characters.

                 if ("#,[]{}&*!|>\'\"%@`".indexOf(ch) != -1) {

                     flowIndicators = true;

                     blockIndicators = true;

                 }

                 if (ch == '?' || ch == ':') {

                     flowIndicators = true;

                     if (followedByWhitespace) {

                         blockIndicators = true;

                     }

                 }

                 if (ch == '-' && followedByWhitespace) {

                     flowIndicators = true;

                     blockIndicators = true;

                 }

             } else {

                 // Some indicators cannot appear within a scalar as well.

                 if (",?[]{}".indexOf(ch) != -1) {

                     flowIndicators = true;

                 }

                 if (ch == ':') {

                     flowIndicators = true;

                     if (followedByWhitespace) {

                         blockIndicators = true;

                     }

                 }

                 if (ch == '#' && preceededByWhitespace) {

                     flowIndicators = true;

                     blockIndicators = true;

                 }

             }

             // Check for line breaks, special, and unicode characters.

             boolean isLineBreak = Constant.LINEBR.has(ch);

             if (isLineBreak) {

                 lineBreaks = true;

             }

             if (!(ch == '\n' || ('\u0020' <= ch && ch <= '\u007E'))) {

                 if ((ch == '\u0085' || ('\u00A0' <= ch && ch <= '\uD7FF') || ('\uE000' <= ch && ch <= '\uFFFD'))

                         && (ch != '\uFEFF')) {

                     // unicode is used

                     if (!this.allowUnicode) {

                         specialCharacters = true;

                     }

                 } else {

                     specialCharacters = true;

                 }

             }

             // Detect important whitespace combinations.

             if (ch == ' ') {

                 if (index == 0) {

                     leadingSpace = true;

                 }

                 if (index == scalar.length() - 1) {

                     trailingSpace = true;

                 }

                 if (previousBreak) {

                     breakSpace = true;

                 }

                 previousSpace = true;

                 previousBreak = false;

             } else if (isLineBreak) {

                 if (index == 0) {

                     leadingBreak = true;

                 }

                 if (index == scalar.length() - 1) {

                     trailingBreak = true;

                 }

                 if (previousSpace) {

                     spaceBreak = true;

                 }

                 previousSpace = false;

                 previousBreak = true;

             } else {

                 previousSpace = false;

                 previousBreak = false;

             }

             // Prepare for the next character.

             index++;

             preceededByWhitespace = Constant.NULL_BL_T.has(ch) || isLineBreak;

             followedByWhitespace = (index + 1 >= scalar.length()

                     || (Constant.NULL_BL_T.has(scalar.charAt(index + 1))) || isLineBreak);

         }

         // Let's decide what styles are allowed.

         boolean allowFlowPlain = true;

         boolean allowBlockPlain = true;

         boolean allowSingleQuoted = true;

         boolean allowDoubleQuoted = true;

         boolean allowBlock = true;

         // Leading and trailing whitespaces are bad for plain scalars.

         if (leadingSpace || leadingBreak || trailingSpace || trailingBreak) {

             allowFlowPlain = allowBlockPlain = false;

         }

         // We do not permit trailing spaces for block scalars.

         if (trailingSpace) {

             allowBlock = false;

         }

         // Spaces at the beginning of a new line are only acceptable for block

         // scalars.

         if (breakSpace) {

             allowFlowPlain = allowBlockPlain = allowSingleQuoted = false;

         }

         // Spaces followed by breaks, as well as special character are only

         // allowed for double quoted scalars.

         if (spaceBreak || specialCharacters) {

             allowFlowPlain = allowBlockPlain = allowSingleQuoted = allowBlock = false;

         }

         // Although the plain scalar writer supports breaks, we never emit

         // multiline plain scalars.

         if (lineBreaks) {

             allowFlowPlain = allowBlockPlain = false;

         }

         // Flow indicators are forbidden for flow plain scalars.

         if (flowIndicators) {

             allowFlowPlain = false;

         }

         // Block indicators are forbidden for block plain scalars.

         if (blockIndicators) {

             allowBlockPlain = false;

         }

         return new ScalarAnalysis(scalar, false, lineBreaks, allowFlowPlain, allowBlockPlain,

                 allowSingleQuoted, allowDoubleQuoted, allowBlock);

     }

     // Writers.

     void flushStream() throws IOException {

         stream.flush();

     }

     void writeStreamStart() {

         // BOM is written by Writer.

     }

     void writeStreamEnd() throws IOException {

         flushStream();

     }

     void writeIndicator(String indicator, boolean needWhitespace, boolean whitespace,

             boolean indentation) throws IOException {

         if (!this.whitespace && needWhitespace) {

             this.column++;

             stream.write(SPACE);

         }

         this.whitespace = whitespace;

         this.indention = this.indention && indentation;

         this.column += indicator.length();

         openEnded = false;

         stream.write(indicator);

     }

     void writeIndent() throws IOException {

         int indent;

         if (this.indent != null) {

             indent = this.indent;

         } else {

             indent = 0;

         }

         if (!this.indention || this.column > indent || (this.column == indent && !this.whitespace)) {

             writeLineBreak(null);

         }

         if (this.column < indent) {

             this.whitespace = true;

             char[] data = new char[indent - this.column];

             for (int i = 0; i < data.length; i++) {

                 data[i] = ' ';

             }

             this.column = indent;

             stream.write(data);

         }

     }

     private void writeLineBreak(String data) throws IOException {

         this.whitespace = true;

         this.indention = true;

         this.column = 0;

         if (data == null) {

             stream.write(this.bestLineBreak);

         } else {

             stream.write(data);

         }

     }

     void writeVersionDirective(String versionText) throws IOException {

         stream.write("%YAML ");

         stream.write(versionText);

         writeLineBreak(null);

     }

     void writeTagDirective(String handleText, String prefixText) throws IOException {

         // XXX: not sure 4 invocations better then StringBuilders created by str

         // + str

         stream.write("%TAG ");

         stream.write(handleText);

         stream.write(SPACE);

         stream.write(prefixText);

         writeLineBreak(null);

     }

     // Scalar streams.

     private void writeSingleQuoted(String text, boolean split) throws IOException {

         writeIndicator("'", true, false, false);

         boolean spaces = false;

         boolean breaks = false;

         int start = 0, end = 0;

         char ch;

         while (end <= text.length()) {

             ch = 0;

             if (end < text.length()) {

                 ch = text.charAt(end);

             }

             if (spaces) {

                 if (ch == 0 || ch != ' ') {

                     if (start + 1 == end && this.column > this.bestWidth && split && start != 0

                             && end != text.length()) {

                         writeIndent();

                     } else {

                         int len = end - start;

                         this.column += len;

                         stream.write(text, start, len);

                     }

                     start = end;

                 }

             } else if (breaks) {

                 if (ch == 0 || Constant.LINEBR.hasNo(ch)) {

                     if (text.charAt(start) == '\n') {

                         writeLineBreak(null);

                     }

                     String data = text.substring(start, end);

                     for (char br : data.toCharArray()) {

                         if (br == '\n') {

                             writeLineBreak(null);

                         } else {

                             writeLineBreak(String.valueOf(br));