/*************************************************************************
 *
 *  OpenOffice.org - a multi-platform office productivity suite
 *
 *  $RCSfile: Process.java,v $
 *
 *  $Revision: 1.8 $
 *
 *  last change: $Author: obo $ $Date: 2006-07-17 14:13:08 $
 *
 *  The Contents of this file are made available subject to
 *  the terms of GNU Lesser General Public License Version 2.1.
 *
 *
 *    GNU Lesser General Public License Version 2.1
 *    =============================================
 *    Copyright 2005 by Sun Microsystems, Inc.
 *    901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License version 2.1, as published by the Free Software Foundation.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *    MA  02111-1307  USA
 *
 ************************************************************************/
package com.sun.star.wizards.web;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;

import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.wizards.common.ConfigSet;
import com.sun.star.wizards.common.FileAccess;
import com.sun.star.wizards.common.UCB;
import com.sun.star.wizards.ui.event.Task;
import com.sun.star.wizards.web.data.CGContent;
import com.sun.star.wizards.web.data.CGDocument;
import com.sun.star.wizards.web.data.CGExporter;
import com.sun.star.wizards.web.data.CGLayout;
import com.sun.star.wizards.web.data.CGPublish;
import com.sun.star.wizards.web.data.CGSettings;
import com.sun.star.wizards.web.export.Exporter;



/**
 * @author rpiterman
 * This class is used to process a CGSession object
 * and generate a site. </br>
 * it does the following: <br/>
 * 1. create a temporary directory.<br/>
 * 2. export documents to the temporary directory.<br/>
 * 3. generate the TOC page, includes copying images from the
 * web wizard work directory and other layout files.<br/>
 * 4. publish, or copy, from the temporary directory to
 * different destinations.<br/>
 * 5. delete the temporary directory.<br/>
 * <br/>
 * to follow up the status/errors it uses a TaskListener object,
 * and an ErrorHandler. <br/>
 * in practice, the TaskListener is the status dialog,
 * and the Errorhandler does the interaction with the user,
 * if something goes wrong.<br/>
 * Note that this class takes it in count that
 * the given session object is prepared for it -
 * all preparations are done in WWD_Events.finishWizard methods.
 * <br/>
 * <br/>
 *
 * note on error handling: <br/>
 * on "catch" clauses I tries to decide whether the
 * exception is fatal or not. For fatal exception an error message
 * is displayed (or rather: the errorHandler is being called...)
 * and a false is returned.
 * In less-fatal errors, the errorHandler "should decide" which means,
 * the user is given the option to "OK" or to "Cancel" and depending
 * on that interaction I cary on.
 */
public class Process implements WebWizardConst, ProcessErrors {

    private static final int TASKS_PER_DOC = 5;
    private static final int TASKS_PER_XSL = 2;
    private static final int TASKS_PER_PUBLISH = 2;

    private static final int TASKS_IN_PREPARE = 1;
    private static final int TASKS_IN_EXPORT = 2;
    private static final int TASKS_IN_GENERATE = 2;
    private static final int TASKS_IN_PUBLISH = 2;
    private static final int TASKS_IN_FINISHUP = 1;

    private CGSettings settings;
    private XMultiServiceFactory xmsf;

    private ErrorHandler errorHandler;


    private String tempDir;
    private FileAccess fileAccess;
    private UCB ucb;

    public Task myTask;

    /**
     * This is a cache for exporters, so I do not need to
     * instanciate the same exporter more than once.
     */
    private Map exporters = new Hashtable(3);

    private boolean result;

    public Process(
        CGSettings settings,
        XMultiServiceFactory xmsf,
        ErrorHandler er
        )
    throws Exception
    {
        this.xmsf = xmsf;
        this.settings = settings;
        fileAccess = new FileAccess(xmsf);
        errorHandler = er;

        ucb = new UCB(xmsf);

        int taskSteps = getTaskSteps();
        myTask = new Task(TASK,TASK_PREPARE, taskSteps);

    }


    /**
     * @return to how many destinations should the
     * generated site be published.
     */
    private int countPublish() {
        int count = 0;
        ConfigSet publishers = settings.cp_DefaultSession.cp_Publishing;
        for (int i = 0; i<publishers.getSize(); i++)
            if (((CGPublish)publishers.getElementAt(i)).cp_Publish)
                count++;
        return count;
    }

    /**
     * @return the number of task steps that this
     * session should have
     */
    private int getTaskSteps() {
        int docs = settings.cp_DefaultSession.cp_Content.cp_Documents.getSize();
        int xsl = 0;
        try {
            xsl = settings.cp_DefaultSession.getLayout().getTemplates(xmsf).size();
        }
        catch (Exception ex) {
        }
        int publish = countPublish();
        int taskSteps =
                TASKS_IN_PREPARE    +
                TASKS_IN_EXPORT     +       docs    *   TASKS_PER_DOC       +
                TASKS_IN_GENERATE   +       xsl     *   TASKS_PER_XSL       +
                TASKS_IN_PUBLISH    +       publish *   TASKS_PER_PUBLISH   +
                TASKS_IN_FINISHUP;
        return taskSteps;
    }

    /**
     * does the job
     */
    public void runProcess() {
        myTask.start();
        try {
            try {
                /*
                 * I use here '&&' so if one of the
                 * methods returns false, the next
                 * will not be called.
                 */
                result = createTempDir(myTask)
                  && export(myTask)
                  && generate(tempDir,myTask)
                  && publish(tempDir,myTask);

            }
            finally {
                //cleanup must be called.
                result = result & cleanup(myTask);
            }
        }
        catch (Exception ex) {
            result = false;
        }

        if (!result)
            myTask.fail();

        //this is a bug protection.
        while (myTask.getStatus() < myTask.getMax())
            myTask.advance(true);

    }

    /**
     * creates a temporary directory.
     * @param task
     * @return true should continue
     */
    private boolean createTempDir(Task task) {

        tempDir = fileAccess.createNewDir(getSOTempDir(xmsf), "wwiztemp");
        if (tempDir == null) {
            error(null,null,ERROR_MKDIR,ErrorHandler.ERROR_PROCESS_FATAL);
            return false;
        }
        else {
            task.advance(true);
            return true;
        }
    }

    /**
     * @param xmsf
     * @return the staroffice /openoffice temporary directory
     */
    static String getSOTempDir(XMultiServiceFactory xmsf) {
        try {
            String s = FileAccess.getOfficePath(xmsf,"Temp","", "");
            return s;
        }
        catch (Exception e) {}
        return null;
    }

    // CLEANUP

    /**
     * delete the temporary directory
     * @return true should continue
     */
    private boolean cleanup(Task task) {

        task.setSubtaskName(TASK_FINISH);
        boolean b = fileAccess.delete(tempDir);
        if (!b)
            error(null,null,ERROR_CLEANUP,ErrorHandler.ERROR_WARNING);
        task.advance(b);
        return b;
    }

//  /**
//   * deletes the given directory
//   * @param dir the directory to delete
//   * @return true if should continue
//   */
//  private boolean cleanup(String dir) {
//
//      boolean success = true;
//
//      if (dir != null && fileAccess.exists(dir,false)) {
//
//          String[] files = fileAccess.listFiles(dir,true);
//
//          for (int i = 0; i < files.length; i++) {
//              if (fileAccess.isDirectory(files[i]))
//                  success = success && cleanup(files[i]);
//              else
//                  success = success && fileAccess.delete(files[i]);
//
//          }
//      }
//      return success && fileAccess.delete(dir);
//  }


    /**
     * This method is used to copy style files to a target
     * Directory: css and background.
     * Note that this method is static since it is
     * also used when displaying a "preview"
     */
    public static void copyMedia(UCB copy, CGSettings settings, String targetDir, Task task ) throws Exception {

        //1. .css
        String sourceDir = FileAccess.connectURLs(settings.workPath , "styles");
        String filename = settings.cp_DefaultSession.getStyle().cp_CssHref;
        copy.copy(sourceDir,filename,targetDir,"style.css");

        task.advance(true);

        //2. background image
        String background = settings.cp_DefaultSession.cp_Design.cp_BackgroundImage;
        if (background != null && !background.equals("")) {
            sourceDir = FileAccess.getParentDir(background);
            filename = background.substring(sourceDir.length());
            copy.copy(sourceDir,filename,targetDir + "/images","background.gif");
        }

        task.advance(true);
    }

    /**
     * Copy "static" files (which are always the same,
     * thus not user-input-dependant) to a target directory.
     * Note that this method is static since it is
     * also used when displaying a "preview"
     * @param copy
     * @param settings
     * @param targetDir
     * @throws Exception
     */
    public static void copyStaticImages(UCB copy, CGSettings settings, String targetDir)
        throws Exception
    {
        copy.copy(FileAccess.connectURLs(settings.workPath , "images") ,targetDir+"/images");
    }


    /**
     * publish the given directory.
     * @param dir the source directory to publish from
     * @param task task tracking.
     * @return true if should continue
     */
    private boolean publish(String dir, Task task ) {
        task.setSubtaskName(TASK_PUBLISH_PREPARE);
        ConfigSet set = settings.cp_DefaultSession.cp_Publishing;
        try {

            copyMedia(ucb, settings, dir,task);
            copyStaticImages(ucb,settings,dir);
            task.advance(true);
        }
        catch (Exception ex) {
            //error in copying media
            error(ex, "", ERROR_PUBLISH_MEDIA, ErrorHandler.ERROR_PROCESS_FATAL);
            return false;
        }

        boolean result = true;

        for (int i = 0; i < set.getSize(); i++) {

            CGPublish p = (CGPublish)set.getElementAt(i);

            if (p.cp_Publish) {

                String key = (String)set.getKey(p);
                task.setSubtaskName(key);

                if (key.equals(ZIP_PUBLISHER))
                    fileAccess.delete(p.cp_URL);

                if (!publish(dir, p, ucb, task)) {
                    return false;
                }

            }
        }

        return result;
    }

    /**
     * publish the given directory to the
     * given target CGPublish.
     * @param dir the dir to copy from
     * @param publish the object that specifies the target
     * @param copy ucb encapsulation
     * @param task task tracking
     * @return true if should continue
     */
    private boolean publish(String dir,CGPublish publish,UCB copy,Task task) {
        try {
            //copy.deleteDirContent(publish.url);
            task.advance(true);
            copy.copy(dir,publish.url);
            task.advance(true);
            return true;
        } catch (Exception e) {
            task.advance(false);
            return error(e,publish, ERROR_PUBLISH,ErrorHandler.ERROR_NORMAL_IGNORE);
        }
    }


    //GENERATING METHODS

    /**
     * Generates the TOC pages for the current session.
     * @param targetDir generating to this directory.
     */
    public boolean generate(String targetDir, Task task) {
        boolean result = false;
        task.setSubtaskName(TASK_GENERATE_PREPARE);


            CGLayout layout = settings.cp_DefaultSession.getLayout();

            try {
                /*
                 * here I create the DOM of the TOC to pass to the XSL
                 */
                Document doc = (Document)settings.cp_DefaultSession.createDOM();
                generate(xmsf,layout,doc ,fileAccess,targetDir,task);

            }
            catch (Exception ex) {
                error(ex, "" , ERROR_GENERATE_XSLT ,ErrorHandler.ERROR_PROCESS_FATAL);
                return false;
            }

            /* copy files which are not xsl from layout directory to
             * website root.
             */
            try {

                task.setSubtaskName(TASK_GENERATE_COPY);

                copyLayoutFiles(ucb,fileAccess,settings,layout,targetDir);

                task.advance(true);

                result = true;
            }
            catch (Exception ex) {
                task.advance(false);
                return error(ex,null,ERROR_GENERATE_COPY,ErrorHandler.ERROR_NORMAL_ABORT);
            }



        return result;

    }

    /**
     * copies layout files which are not .xsl files
     * to the target directory.
     * @param ucb UCB encapsulatzion object
     * @param fileAccess filaAccess encapsulation object
     * @param settings web wizard settings
     * @param layout the layout object
     * @param targetDir the target directory to copy to
     * @throws Exception
     */
    public static void copyLayoutFiles(UCB ucb, FileAccess fileAccess, CGSettings settings, CGLayout layout, String targetDir)
        throws Exception
    {
        String filesPath = fileAccess.getURL(
            FileAccess.connectURLs(settings.workPath ,  "layouts/"), layout.cp_FSName );
        ucb.copy(filesPath,targetDir,new ExtensionVerifier("xsl"));

    }

    /**
     * generates the TOC page for the given layout.
     * This method might generate more than one file, depending
     * on how many .xsl files are in the
     * directory specifies by the given layout object.
     * @param xmsf
     * @param layout specifies the layout to use.
     * @param doc the DOM representation of the web wizard session
     * @param fileAccess encapsulation of FileAccess
     * @param targetPath target directory
     * @param task
     * @throws Exception
     */
    public static void generate(
        XMultiServiceFactory xmsf,
        CGLayout layout,
        Document doc,
        FileAccess fileAccess,
        String targetPath,
        Task task)
        throws Exception
    {
        /*
         * a map that contains xsl templates. the keys are the xsl file names.
         */
        Map templates = layout.getTemplates(xmsf);

        task.advance(true,TASK_GENERATE_XSL);

        /*
         * each template generates a page.
         */
        for (Iterator i = templates.keySet().iterator() ; i.hasNext(); ) {

            String key = "";

            key = (String)i.next();

            Transformer transformer = ((Templates)templates.get(key)).newTransformer();

            doc.normalize();
            task.advance(true);

            /*
             * The target file name is like the xsl template filename
             * without the .xsl extension.
             */
            String fn = fileAccess.getPath( targetPath, key.substring(0,key.length()-4));
            File f = new File(fn);
            FileOutputStream oStream = new FileOutputStream(f);
            // Due to a problem occuring when using Xalan-Java 2.6.0 and
            // Java 1.5.0, wrap f in a FileOutputStream here (otherwise, the
            // StreamResult's getSystemId would return a "file:/..." URL while
            // the Xalan code expects a "file:///..." URL):
            transformer.transform(
                new DOMSource(doc), new StreamResult(oStream) );
            oStream.close();
            task.advance(true);
        }
    }


    /**
     * I broke the export method to two methods
     * in a time where a tree with more than one contents was planned.
     * I left it that way, because it may be used in the future.
     * @param task
     * @return
     */
    private boolean export(Task task) {

        return export(settings.cp_DefaultSession.cp_Content, tempDir, task);

    }

    /**
     * This method could actually, with light modification, use recursion.
     * In the present situation, where we only use a "flat" list of
     * documents, instead of the original plan to use a tree,
     * the recursion is not implemented.
     * @param content the content ( directory-like, contains documents)
     * @param dir (target directory for exporting this content.
     * @param task
     * @return true if should continue
     */
    private boolean export(CGContent content, String dir, Task task) {
        int toPerform = 1;
        String contentDir = dir;

        try {

            task.setSubtaskName(TASK_EXPORT_PREPARE);

            /* 1. create a content directory.
             * each content (at the moment there is only one :-( )
             * is created in its own directory.
             * faileure here is fatal.
             */
            contentDir = fileAccess.createNewDir(dir,content.cp_Name);
            if (contentDir == null || contentDir.equals("") )
                throw new IOException("Directory " + dir + " could not be created.");
            content.dirName = FileAccess.getFilename(contentDir);

            task.advance(true,TASK_EXPORT_DOCUMENTS);
            toPerform--;

            /*2. export all documents and sub contents.
             * (at the moment, only documents, no subcontents)
             */
            Object item = null;
            for (int i = 0; i < content.cp_Documents.getSize(); i++) {
                try {
                    item = content.cp_Documents.getElementAt(i);
                    /*
                     * In present this is always the case.
                     * may be in the future, when
                     * a tree is used, it will be abit different.
                     */
                    if (item instanceof CGDocument) {
                        if (!export((CGDocument) item, contentDir,task))
                          return false;
                    }
                    else
                        /*
                         * we never get here since we
                         * did not implement sub-contents.
                         */
                        if (!export((CGContent) item, contentDir,task))
                            return false;
                }
                catch (SecurityException sx) {
                    // nonfatal
                    if (!error(sx,item, ERROR_EXPORT_SECURITY,ErrorHandler.ERROR_NORMAL_IGNORE))
                       return false;
                    result = false;
                }
            }
        }
        catch (IOException iox) {
            //nonfatal
            return error(iox,content,ERROR_EXPORT_IO,ErrorHandler.ERROR_NORMAL_IGNORE);

        }
        catch (SecurityException se) {
            //nonfatal
            return error(se,content,ERROR_EXPORT_SECURITY,ErrorHandler.ERROR_NORMAL_IGNORE);
        }
        failTask(task,toPerform);
        return true;

    }

    /**
     * exports a single document
     * @param doc the document to export
     * @param dir the target directory
     * @param task task tracking
     * @return true if should continue
     */
    private boolean export(CGDocument doc, String dir,Task task) {

        //first I check if the document was already validated...
        if (!doc.valid)
          try {
            doc.validate(xmsf,null);
          }
          catch (Exception ex){
            //fatal
            error(ex,doc,ERROR_DOC_VALIDATE,ErrorHandler.ERROR_PROCESS_FATAL);
            return false;
          }
        //get the exporter specified for this document
        CGExporter exporter = (CGExporter)settings.cp_Exporters.getElement(doc.cp_Exporter);


        try {

            /*
             * here I calculate the destination filename.
             * I take the original filename (docFilename), substract the extension, (docExt) -> (fn)
             * and find an available filename which starts with
             * this filename, but with the new extension. (destExt)
             */
            String docFilename = FileAccess.getFilename(doc.cp_URL);

            String docExt = FileAccess.getExtension(docFilename);
            String fn = doc.localFilename.substring(0,doc.localFilename.length()-docExt.length()-1); //filename without extension

            /*
             * the copyExporter does not change
             * the extension of the target...
             */
            String destExt = (
                exporter.cp_Extension.equals("")
                ? FileAccess.getExtension(docFilename)
                : exporter.cp_Extension
            );

            /* if this filter needs to export to its own directory...
             * this is the case in, for example, impress html export
             */
            if (exporter.cp_OwnDirectory) { //+++
                  dir = fileAccess.createNewDir(dir, fn );
                  doc.dirName = FileAccess.getFilename(dir);
            }

            /*
             * if two files with the same name
             * need to be exported ? So here
             * i get a new filename, so I do not
             * overwrite files...
             */
            String file = fileAccess.getNewFile(dir,fn,destExt);


            /* set filename with extension.
             * this will be used by the exporter,
             * and to generate the TOC.
             */
            doc.urlFilename = FileAccess.getFilename(file);

            task.advance(true);

            try {
                //export
                getExporter(exporter).export(doc, file, xmsf, task);
                task.advance(true);
            }
            /*
             * getExporter(..) throws
             * IllegalAccessException, InstantiationException, ClassNotFoundException
             * export() throws Exception
             */
            catch (Exception ex) {
                //nonfatal
                if (!error(ex, doc, ERROR_EXPORT, ErrorHandler.ERROR_NORMAL_IGNORE))
                  return false;
            }
        }
        catch (Exception ex) {
            //nonfatal
            if (!error(ex,doc,ERROR_EXPORT_MKDIR,ErrorHandler.ERROR_NORMAL_ABORT))
              return false;
        }

        return true;

    }

    /**
     * submit an error.
     * @param ex the exception
     * @param arg1 error argument
     * @param arg2 error argument 2
     * @param errType error type
     * @return the interaction result
     */
    private boolean error(Exception ex, Object arg1, int arg2, int errType) {
        result = false;
        return errorHandler.error(ex,arg1,arg2,errType);
    }


    /**
     * advances the given task in the given count of steps,
     * marked as failed.
     * @param task the task to advance
     * @param count the number of steps to advance
     */
    private void failTask(Task task, int count) {
        while (count-- > 0)
          task.advance(false);
    }

    /**
     * creates an instance of the exporter class
     * as specified by the
     * exporter object.
     * @param export specifies the exporter to be created
     * @return the Exporter instance
     * @throws ClassNotFoundException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    private Exporter createExporter(CGExporter export)
        throws  ClassNotFoundException,
                IllegalAccessException,
                InstantiationException
    {
        Exporter e = (Exporter) Class.forName(export.cp_ExporterClass).newInstance();
        e.init(export);
        return e;
    }

    /**
     * searches the an exporter for the given CGExporter object
     * in the cache.
     * If its not there, creates it, stores it in the cache and
     * returns it.
     * @param export specifies the needed exporter.
     * @return an Exporter instance
     * @throws ClassNotFoundException thrown when using Class.forName(string)
     * @throws IllegalAccessException thrown when using Class.forName(string)
     * @throws InstantiationException thrown when using Class.forName(string)
     */
    private Exporter getExporter(CGExporter export)
        throws  ClassNotFoundException,
                IllegalAccessException,
                InstantiationException
    {
        Exporter exp = (Exporter)exporters.get(export);
        if (exp == null) {
            exp = createExporter(export);
            exporters.put(export,exp);
        }
        return exp;
    }

    /**
     * @return tru if everything went smooth, false
     * if error(s) accured.
     */
    public boolean getResult() {
        return (myTask.getFailed() == 0) && result;
    }

}
