/*
 * Copyright (c) 2011, 2019 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Blaise Doughan - 2.4 - initial implementation
package org.eclipse.persistence.oxm.record;

import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;

import org.eclipse.persistence.exceptions.XMLMarshalException;
import org.eclipse.persistence.internal.oxm.Constants;
import org.eclipse.persistence.internal.oxm.NamespaceResolver;
import org.eclipse.persistence.internal.oxm.XPathFragment;
import org.eclipse.persistence.internal.oxm.record.XMLFragmentReader;
import org.w3c.dom.Attr;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;

/**
 * <p>Use this type of MarshalRecord when the marshal target is a Writer and the
 * JSON should be formatted with carriage returns and indenting.</p>
 * <p><code>
 * XMLContext xmlContext = new XMLContext("session-name");<br>
 * XMLMarshaller xmlMarshaller = xmlContext.createMarshaller();<br>
 * JSONFormattedWriterRecord jsonFormattedRecord = new JSONFormattedWriterRecord();<br>
 * jsonFormattedWriterRecord.setWriter(myWriter);<br>
 * xmlMarshaller.marshal(myObject, jsonFormattedWriterRecord);<br>
 * </code></p>
 * <p>If the marshal(Writer) and setMediaType(MediaType.APPLICATION_JSON) and
 *  setFormattedOutput(true) method is called on XMLMarshaller, then the Writer
 *  is automatically wrapped in a JSONFormattedWriterRecord.</p>
 * <p><code>
 * XMLContext xmlContext = new XMLContext("session-name");<br>
 * XMLMarshaller xmlMarshaller = xmlContext.createMarshaller();<br>
 * xmlMarshaller.setMediaType(MediaType.APPLICATION_JSON);
 * xmlMarshaller.setFormattedOutput(true);<br>
 * xmlMarshaller.marshal(myObject, myWriter);<br>
 * </code></p>
 * @see org.eclipse.persistence.oxm.XMLMarshaller
 */
public class JSONFormattedWriterRecord extends JSONWriterRecord {

    private String tab;
    private int numberOfTabs;
    private boolean isLastEventText;

    public JSONFormattedWriterRecord() {
        numberOfTabs = 0;
        isLastEventText = false;
    }

    public JSONFormattedWriterRecord(OutputStream outputStream){
        this();
        this.writer = new OutputStreamOutput(outputStream);
    }

    public JSONFormattedWriterRecord(OutputStream outputStream, String callbackName){
        this(outputStream);
        setCallbackName(callbackName);
    }

    public JSONFormattedWriterRecord(Writer writer){
        this();
        setWriter(writer);
    }

    public JSONFormattedWriterRecord(Writer writer, String callbackName){
        this(writer);
        setCallbackName(callbackName);
    }

    private String tab() {
        if (tab == null) {
            tab = getMarshaller().getIndentString();
        }
        return tab;
    }

    @Override
    public void startDocument(String encoding, String version) {
        super.startDocument(encoding, version);
        numberOfTabs++;
    }

    /**
     * INTERNAL:
     */
    @Override
    public void endDocument() {
         numberOfTabs--;
         super.endDocument();
    }

    @Override
    protected void closeComplex() throws IOException {
        writer.writeCR();
        for (int x = 0; x < numberOfTabs; x++) {
            writeValue(tab(), false);
        }
        writer.write('}');
    }

    /**
     * INTERNAL:
     */
    @Override
    public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
        try {
            if(level.isFirst()) {
                level.setFirst(false);
            } else {
                writer.write(',');
            }
            if(xPathFragment.nameIsText()){
                if(level.isCollection() && level.isEmptyCollection()) {
                    writer.write('[');
                    writer.write(' ');
                    level.setEmptyCollection(false);
                    level.setNeedToOpenComplex(false);
                    level = new Level(true, true, false, level);
                    numberOfTabs++;
                    return;
                }
            }

            if(level.isNeedToOpenComplex()){
                if (!level.isNestedArray()) {
                    writer.write('{');
                }
                level.setNeedToOpenComplex(false);
                level.setNeedToCloseComplex(true);
            }
            if (!isLastEventText) {
                if(level.isCollection() && !level.isEmptyCollection()) {
                    writer.write(' ');
                } else {
                    writer.writeCR();
                    for (int x = 0; x < numberOfTabs; x++) {
                        writeValue(tab(), false);
                    }
                }
            }

          //write the key unless this is a a non-empty collection
            if(!(level.isCollection() && !level.isEmptyCollection())){
                if (!level.isNestedArray()) {
                    super.writeKey(xPathFragment);
                }
                //if it is the first thing in the collection also add the [
                if(level.isCollection() && level.isEmptyCollection()){
                     writer.write('[');
                     writer.write(' ');
                     level.setEmptyCollection(false);
                }
            }

            numberOfTabs++;
            isLastEventText = false;
            charactersAllowed = true;
            if (xPathFragment.getXMLField() != null && xPathFragment.getXMLField().isNestedArray() && this.marshaller.getJsonTypeConfiguration().isJsonDisableNestedArrayName()) {
                level = new Level(true, true, true, level);
            } else {
                level = new Level(true, true, false, level);
            }
        } catch (IOException e) {
            throw XMLMarshalException.marshalException(e);
        }
    }

    /**
     * INTERNAL:
     */
    @Override
    public void element(XPathFragment frag) {
    }

    @Override
    protected void writeListSeparator() throws IOException{
        super.writeListSeparator();
        writer.write(' ');
    }

    @Override
    protected void writeSeparator() throws IOException{
        writer.write(' ');
        writer.write(Constants.COLON);
        writer.write(' ');
    }

    /**
     * INTERNAL:
     */
    @Override
    public void endElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
        isLastEventText = false;
        numberOfTabs--;
        super.endElement(xPathFragment, namespaceResolver);
    }

    @Override
    public void startCollection() {
        if(null == level) {
            try {
                super.startCollection();
                writer.write(' ');
            } catch(IOException e) {
                throw XMLMarshalException.marshalException(e);
            }
        } else {
            super.startCollection();
        }
    }
    @Override
    protected void endEmptyCollection(){
        super.endCollection();
    }

    @Override
    public void endCollection() {
        try {
            writer.write(' ');
            super.endCollection();
        } catch(IOException e) {
            throw XMLMarshalException.marshalException(e);
        }
    }

    /**
     * INTERNAL:
     */
    @Override
    public void characters(String value) {
        super.characters(value);
        isLastEventText = true;
    }

    /**
     * Receive notification of a node.
     * @param node The Node to be added to the document
     * @param namespaceResolver The NamespaceResolver can be used to resolve the
     * namespace URI/prefix of the node
     */
    @Override
    public void node(Node node, NamespaceResolver namespaceResolver) {
        if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
            Attr attr = (Attr) node;
            String resolverPfx = null;
            if (getNamespaceResolver() != null) {
                resolverPfx = getNamespaceResolver().resolveNamespaceURI(attr.getNamespaceURI());
            }
            // If the namespace resolver contains a prefix for the attribute's URI,
            // use it instead of what is set on the attribute
            if (resolverPfx != null) {
                attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, resolverPfx+Constants.COLON+attr.getLocalName(), attr.getNodeValue());
            } else {
                attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, attr.getName(), attr.getNodeValue());
                // May need to declare the URI locally
                if (attr.getNamespaceURI() != null) {
                    attribute(javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI, Constants.EMPTY_STRING, javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON + attr.getPrefix(), attr.getNamespaceURI());
                    this.getNamespaceResolver().put(attr.getPrefix(), attr.getNamespaceURI());
                }
            }
        } else if (node.getNodeType() == Node.TEXT_NODE) {
            characters(node.getNodeValue(), false, false);
        } else {
            try {
                JSONFormattedWriterRecordContentHandler wrcHandler = new JSONFormattedWriterRecordContentHandler();
                XMLFragmentReader xfragReader = new XMLFragmentReader(namespaceResolver);
                xfragReader.setContentHandler(wrcHandler);
                xfragReader.setProperty("http://xml.org/sax/properties/lexical-handler", wrcHandler);
                xfragReader.parse(node);
            } catch (SAXException sex) {
                throw XMLMarshalException.marshalException(sex);
            }
        }
    }

    @Override
    protected void writeKey(XPathFragment xPathFragment) throws IOException {
        writer.writeCR();
        for (int x = 0; x < numberOfTabs; x++) {
            writeValue(tab(), false);
        }
        super.writeKey(xPathFragment);
    }


    /**
     * This class will typically be used in conjunction with an XMLFragmentReader.
     * The XMLFragmentReader will walk a given XMLFragment node and report events
     * to this class - the event's data is then written to the enclosing class'
     * writer.
     *
     * @see org.eclipse.persistence.internal.oxm.record.XMLFragmentReader
     * @see org.eclipse.persistence.oxm.record.WriterRecord.WriterRecordContentHandler
     */
    private class JSONFormattedWriterRecordContentHandler extends JSONWriterRecordContentHandler {
        // --------------------- CONTENTHANDLER METHODS --------------------- //
        @Override
        public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
            XPathFragment xPathFragment = new XPathFragment(localName);
            xPathFragment.setNamespaceURI(namespaceURI);

            JSONFormattedWriterRecord.this.endElement(xPathFragment, namespaceResolver);
        }


    }

}