package net.sf.logdistiller.reports;

/*
 * 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.
 */

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

import org.jdom.*;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

import net.sf.logdistiller.LogDistillation;
import net.sf.logdistiller.LogDistiller;
import net.sf.logdistiller.ReportFormat;

/**
 * XML report format.
 *
 * @since 0.8
 */
public class XmlReport
    extends ReportFormat
{
    public XmlReport()
    {
        super( "xml" );
    }

    public String getContentType()
    {
        return "text/xml";
    }

    public String getFileExtension()
    {
        return "xml";
    }

    public void report( LogDistillation ld, Writer output )
        throws IOException
    {
        LogDistiller definition = ld.getDefinition();

        Element report = new Element( "logdistiller-report" );
        Element elmt = new Element( "logdistiller" );
        elmt.setAttribute( "id", definition.getOutput().getId() );
        elmt.setAttribute( "description", definition.getDescription() );
        elmt.setAttribute( "logtype", definition.getLogType().getId() );
        elmt.setAttribute( "version", ld.getVersion() );
        report.addContent( elmt );

        elmt = new Element( "logdistillation" );
        if ( ld.getContent() != null )
        {
            elmt.setAttribute( "content", ld.getContent() );
        }
        String logsUrl = definition.getOutput().getUrl();
        if ( logsUrl != null )
        {
            elmt.setAttribute( "logsUrl", logsUrl );
        }
        elmt.setAttribute( "beginTime", String.valueOf( ld.getBeginTime() ) );
        elmt.setAttribute( "endTime", String.valueOf( ld.getEndTime() ) );
        elmt.setAttribute( "eventCount", String.valueOf( ld.getEventCount() ) );
        elmt.setAttribute( "eventBytes", String.valueOf( ld.getEventBytes() ) );
        elmt.setAttribute( "skippedEventCount", String.valueOf( ld.getSkippedEventCount() ) );
        elmt.setAttribute( "skippedEventBytes", String.valueOf( ld.getSkippedEventBytes() ) );
        for ( String warning : definition.getWarnings() )
        {
            elmt.addContent( new Element( "warning" ).setText( warning ) );
        }
        report.addContent( elmt );

        // report for categories, and corresponding groups
        for ( LogDistillation.Category category : ld.listCategoriesToReport() )
        {
            elmt.addContent( newCategory( category ) );
        }

        // report for groups without category
        for ( LogDistillation.Group group : ld.listGroupsToReport() )
        {
            elmt.addContent( newGroup( group ) );
        }

        new XMLOutputter( Format.getPrettyFormat() ).output( new Document( report ), output );
    }

    private Element newCategory( LogDistillation.Category category )
    {
        Element elmt = new Element( "category" );
        LogDistiller.Category definition = category.getDefinition();
        elmt.setAttribute( "id", definition.getId() );
        elmt.setAttribute( "description", definition.getDescription() );
        elmt.setAttribute( "eventCount", String.valueOf( category.sumEventCount() ) );
        elmt.setAttribute( "eventBytes", String.valueOf( category.sumBytes() ) );
        for ( LogDistillation.Group group : category.listGroupsToReport() )
        {
            elmt.addContent( newGroup( group ) );
        }
        return elmt;
    }

    private Element newGroup( LogDistillation.Group group )
    {
        Element elmt = new Element( "group" );
        LogDistiller.Group definition = group.getDefinition();
        elmt.setAttribute( "id", definition.getId() );
        elmt.setAttribute( "description", definition.getDescription() );
        elmt.setAttribute( "eventCount", String.valueOf( group.getEventCount() ) );
        elmt.setAttribute( "eventBytes", String.valueOf( group.getBytes() ) );
        if ( definition.continueProcessing() )
        {
            elmt.setAttribute( "continueProcessing", "true" );
        }
        addPluginsGlobalReport( group, new XmlPluginReport( elmt ) );
        return elmt;
    }

    public void report( LogDistillation.Group group, Writer output )
        throws IOException
    {
        LogDistillation ld = group.getLogdistillation();
        LogDistiller.Group definition = group.getDefinition();
        Element elmt;

        Element report = new Element( "logdistiller-group-report" );
        report.addContent( elmt = new Element( "group" ) );
        elmt.setAttribute( "id", definition.getId() );
        elmt.setAttribute( "description", definition.getDescription() );
        elmt.setAttribute( "continueProcessing", definition.continueProcessing() ? "true" : "false" );
        definition.dumpConditions( elmt );

        report.addContent( elmt = new Element( "logdistillation" ) );
        if ( ld.getContent() != null )
        {
            elmt.setAttribute( "content", ld.getContent() );
        }
        String logsUrl = ld.getDefinition().getOutput().getUrl();
        if ( logsUrl != null )
        {
            elmt.setAttribute( "logsUrl", logsUrl );
        }
        elmt.setAttribute( "eventCount", String.valueOf( ld.getEventCount() ) );
        elmt.setAttribute( "eventBytes", String.valueOf( ld.getEventBytes() ) );

        if ( definition.getSave() )
        {
            Element save = new Element( "save" );
            save.setAttribute( "logFile", group.getLogFile().getAbsolutePath() );
            save.setAttribute( "savedEventCount", String.valueOf( group.getSavedEventCount() ) );
            save.setAttribute( "maxSaveCount", String.valueOf( group.getMaxSaveCount() ) );
            save.setAttribute( "maxSaveBytes", String.valueOf( group.getMaxSaveBytes() ) );
            if ( logsUrl != null )
            {
                save.setAttribute( "logsUrl", ld.getDefinition().getOutput().getUrl( group.getLogFile().getName() ) );
            }
            elmt.addContent( save );
        }
        addPluginsGroupReport( group, new XmlPluginReport( elmt ) );

        new XMLOutputter( Format.getPrettyFormat() ).output( new Document( report ), output );
    }

    private static class XmlPluginReport
        extends PluginReport
    {
        private final Element elmt;

        private Element pluginElmt;

        public XmlPluginReport( Element elmt )
        {
            this.elmt = elmt;
            pluginElmt = null;
        }

        public void beginPluginReport( LogDistillation.Plugin plugin, String description )
        {
            pluginElmt = new Element( "plugin" ).setAttribute( "type", plugin.getDefinition().getType() );
            pluginElmt.addContent( new Element( "description" ).setText( description ) );
        }

        public void addLink( String filename, String description )
        {
            pluginElmt.addContent( new Element( "link" ).setAttribute( "filename", filename ).setText( description ) );
        }

        public void addParam( String param, String value )
        {
            pluginElmt.addContent( new Element( "param" ).setAttribute( "name", param ).setText( value ) );
        }

        public void addItem( int count, String description )
        {
            pluginElmt.addContent( new Element( "item" ).setAttribute( "count", String.valueOf( count ) ).setText(
                                                                                                                   description ) );
        }

        public void endPluginReport()
        {
            elmt.addContent( pluginElmt );
            pluginElmt = null;
        }
    }
}