package com.fasterxml.jackson.jr.ob;

import java.io.IOException;
import java.util.*;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.io.SegmentedStringWriter;
import com.fasterxml.jackson.core.util.ByteArrayBuilder;

import com.fasterxml.jackson.jr.ob.JSON.Feature;
import com.fasterxml.jackson.jr.ob.comp.SequenceComposer;

Root-level composer object that acts as streaming "builder" object, using an underlying JsonGenerator object. This is similar to ArrayComposer, but does not have parent composer (so no end() method), but does implement Closeable 
Type parameters:
<T> – Type of result being composed./**
 * Root-level composer object that acts as streaming "builder"
 * object, using an underlying {@link com.fasterxml.jackson.core.JsonGenerator} object.
 * This is similar to {@link com.fasterxml.jackson.jr.ob.comp.ArrayComposer}, but does not
 * have parent composer (so no <code>end()</code> method),
 * but does implement {@link java.io.Closeable}
 * 
 * @param <T> Type of result being composed.
 */
public class JSONComposer<T>
    extends SequenceComposer<JSONComposer<T>>
{
    protected final int _features;

    protected final boolean _closeGenerator;
    
    protected T _result;

    protected SegmentedStringWriter _stringWriter;
    
    protected ByteArrayBuilder _byteWriter;
    
    public JSONComposer(int features, JsonGenerator gen, boolean closeGenerator)
    {
        super(gen);
        _features = features;
        _stringWriter = null;
        _byteWriter = null;
        _closeGenerator = closeGenerator;
    }

    protected JSONComposer(int features, JsonGenerator gen, SegmentedStringWriter w)
    {
        super(gen);
        _features = features;
        _stringWriter = w;
        _byteWriter = null;
        _closeGenerator = true;
    }

    protected JSONComposer(int features, JsonGenerator gen, ByteArrayBuilder w)
    {
        super(gen);
        _features = features;
        _stringWriter = null;
        _byteWriter = w;
        _closeGenerator = true;
    }

    protected JSONComposer(int features, T result)
    {
        super(null);
        _features = features;
        _result = result;
        _stringWriter = null;
        _byteWriter = null;
        _closeGenerator = false;
    }
    
    /*
    /**********************************************************************
    /* API, factory methods
    /**********************************************************************
     */

    public static <RESULT> JSONComposer<RESULT> streamComposer(int features,
            JsonGenerator gen, boolean closeGenerator)
    {
        return new JSONComposer<RESULT>(features, gen, closeGenerator);
    }
    
    public static JSONComposer<String> stringComposer(int features,
            JsonGenerator gen, SegmentedStringWriter w) {
        return new JSONComposer<String>(features, gen, w);
    }

    public static JSONComposer<byte[]> bytesComposer(int features,
            JsonGenerator gen, ByteArrayBuilder w) {
        return new JSONComposer<byte[]>(features, gen, w);
    }

    public static <T extends Collection<Object>> JSONComposer<T> collectionComposer(int features,
            T coll) {
        return new JSONComposer<T>(features, coll);
    }

    public static JSONComposer<Map<String,Object>> mapComposer(int features,
            Map<String,Object> map) {
        return new JSONComposer<Map<String,Object>>(features, map);
    }
    
    /*
    /**********************************************************************
    /* API, life-cycle
    /**********************************************************************
     */

    
Method to call to complete composition, flush any pending content,
and return instance of specified result type.
/**
     * Method to call to complete composition, flush any pending content,
     * and return instance of specified result type.
     */
    @SuppressWarnings("unchecked")
    public T finish() throws IOException
    {
        if (_open) {
            _closeChild();
            _open = false;
            if (_closeGenerator) {
                _generator.close();
            } else if (Feature.FLUSH_AFTER_WRITE_VALUE.isEnabled(_features)) {
                _generator.flush();
            }
        }
        if (_result == null) {
            Object x;
            if (_stringWriter != null) {
                x = _stringWriter.getAndClear();
                _stringWriter = null;
            } else if (_byteWriter != null) {
                x = _byteWriter.toByteArray();
                _byteWriter = null;
            } else {
                x = _generator.getOutputTarget();
            }
            _result = (T) x;
        }
        return _result;
    }
    
    /*
    /**********************************************************************
    /* Abstract method impls
    /**********************************************************************
     */

    @Override
    protected JSONComposer<T> _start() throws IOException {
        // Should never be called
        throw _illegalCall();
    }

    @Override
    protected Object _finish() throws IOException {
        // Should never be called
        throw _illegalCall();
    }
}