/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.any23.vocab;

import org.apache.any23.rdf.RDFUtils;
import org.apache.any23.util.DiscoveryUtils;
import org.apache.any23.util.StringUtils;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import org.eclipse.rdf4j.model.vocabulary.RDFS;
import org.eclipse.rdf4j.rio.RDFFormat;
import org.eclipse.rdf4j.rio.RDFHandlerException;
import org.eclipse.rdf4j.rio.RDFWriter;
import org.eclipse.rdf4j.rio.Rio;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Constructor;
import java.util.List;
import java.util.Map;

/**
 * This class provides a set of methods for generating <a href="http://www.w3.org/TR/rdf-schema/">RDF Schema</a>.
 *
 * @author Michele Mostarda (mostarda@fbk.eu)
 */
public class RDFSchemaUtils {

    private static final String RDF_XML_SEPARATOR = StringUtils.multiply('=', 100);

    private RDFSchemaUtils() {
    }

    /**
     * Serializes a vocabulary composed of the given <code>namespace</code>, <code>resources</code> and
     * <code>properties</code>.
     *
     * @param namespace
     *            vocabulary namespace.
     * @param classes
     *            list of classes.
     * @param properties
     *            list of properties.
     * @param comments
     *            map of resource comments.
     * @param writer
     *            writer to print out the RDF Schema triples.
     *
     * @throws RDFHandlerException
     *             if there is an error handling the RDF
     */
    public static void serializeVocabulary(IRI namespace, IRI[] classes, IRI[] properties, Map<IRI, String> comments,
            RDFWriter writer) {
        writer.startRDF();
        for (IRI clazz : classes) {
            writer.handleStatement(RDFUtils.quad(clazz, RDF.TYPE, RDFS.CLASS, namespace));
            writer.handleStatement(RDFUtils.quad(clazz, RDFS.MEMBER, namespace, namespace));
            final String comment = comments.get(clazz);
            if (comment != null)
                writer.handleStatement(RDFUtils.quad(clazz, RDFS.COMMENT, RDFUtils.literal(comment), namespace));
        }
        for (IRI property : properties) {
            writer.handleStatement(RDFUtils.quad(property, RDF.TYPE, RDF.PROPERTY, namespace));
            writer.handleStatement(RDFUtils.quad(property, RDFS.MEMBER, namespace, namespace));
            final String comment = comments.get(property);
            if (comment != null)
                writer.handleStatement(RDFUtils.quad(property, RDFS.COMMENT, RDFUtils.literal(comment), namespace));
        }
        writer.endRDF();
    }

    /**
     * Serializes the given <code>vocabulary</code> to triples over the given <code>writer</code>.
     *
     * @param vocabulary
     *            vocabulary to be serialized.
     * @param writer
     *            output writer.
     *
     * @throws RDFHandlerException
     *             if there is an error handling the RDF
     */
    public static void serializeVocabulary(Vocabulary vocabulary, RDFWriter writer) {
        serializeVocabulary(vocabulary.getNamespace(), vocabulary.getClasses(), vocabulary.getProperties(),
                vocabulary.getComments(), writer);
    }

    /**
     * Serializes the given <code>vocabulary</code> to <i>NQuads</i> over the given output stream.
     *
     * @param vocabulary
     *            vocabulary to be serialized.
     * @param format
     *            output format for vocabulary.
     * @param willFollowAnother
     *            if <code>true</code> another vocab will be printed in the same stream.
     * @param ps
     *            output stream.
     *
     * @throws RDFHandlerException
     *             if there is an error handling the RDF
     */
    public static void serializeVocabulary(Vocabulary vocabulary, RDFFormat format, boolean willFollowAnother,
            PrintStream ps) {
        final RDFWriter rdfWriter;
        if (format == RDFFormat.RDFXML) {
            rdfWriter = Rio.createWriter(RDFFormat.RDFXML, ps);
            if (willFollowAnother)
                ps.print("\n");
            ps.print(RDF_XML_SEPARATOR);
            ps.print("\n");
        } else {
            rdfWriter = Rio.createWriter(format, ps);
        }
        serializeVocabulary(vocabulary, rdfWriter);
    }

    /**
     * Serialized the given <code>vocabulary</code> to <i>NQuads</i> and return them as string.
     *
     * @param vocabulary
     *            vocabulary to be serialized.
     * @param format
     *            output format for vocabulary.
     *
     * @return string contained serialization.
     *
     * @throws RDFHandlerException
     *             if there is an error handling the RDF
     */
    public static String serializeVocabulary(Vocabulary vocabulary, RDFFormat format) {
        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps;
        try {
            ps = new PrintStream(baos, true, "UTF-8");
        } catch (UnsupportedEncodingException e1) {
            throw new RuntimeException("UTF-8 encoding error when serializing the vocabulary to NQuads.", e1);
        }
        serializeVocabulary(vocabulary, format, false, ps);
        ps.close();
        try {
            return baos.toString("UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("Error writing ByteArrayOutputStream to String with \"UTF-8\" encoding!");
        }
    }

    /**
     * Serializes all the vocabularies to <i>NQuads</i> over the given output stream.
     *
     * @param format
     *            output format for vocabularies.
     * @param ps
     *            output print stream.
     */
    public static void serializeVocabularies(RDFFormat format, PrintStream ps) {
        final Class<Vocabulary> vocabularyClass = Vocabulary.class;
        @SuppressWarnings("rawtypes")
        final List<Class> vocabularies = DiscoveryUtils.getClassesInPackage(vocabularyClass.getPackage().getName(),
                vocabularyClass);
        int currentIndex = 0;
        for (Class<?> vocabClazz : vocabularies) {
            final Vocabulary instance;
            try {
                final Constructor<?> constructor = vocabClazz.getDeclaredConstructor();
                constructor.trySetAccessible();
                instance = (Vocabulary) constructor.newInstance();
            } catch (Exception e) {
                throw new RuntimeException("Error while instantiating vocabulary class " + vocabClazz, e);
            }
            try {
                serializeVocabulary(instance, format, currentIndex < vocabularies.size() - 2, ps);
            } catch (RDFHandlerException rdfhe) {
                throw new RuntimeException("Error while serializing vocabulary.", rdfhe);
            }
        }
    }

}
