/*
 * Copyright (C) 2009 eXo Platform SAS.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software 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 software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.exoplatform.services.jcr.api.importing;

import org.exoplatform.services.jcr.JcrAPIBaseTest;
import org.exoplatform.services.jcr.core.ExtendedSession;
import org.exoplatform.services.jcr.core.ExtendedWorkspace;
import org.exoplatform.services.jcr.impl.core.nodetype.NodeTypeManagerImpl;
import org.exoplatform.services.jcr.util.IdGenerator;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.jcr.ImportUUIDBehavior;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

/**
 * Created by The eXo Platform SAS.
 * 
 * @author <a href="mailto:Sergey.Kabashnyuk@gmail.com">Sergey Kabashnyuk</a>
 * @version $Id: AbstractImportTest.java 14244 2008-05-14 11:44:54Z ksm $
 */
public abstract class AbstractImportTest extends JcrAPIBaseTest
{
   /**
    * Initialization flag.
    */
   private static boolean isInitialized = false;

   /**
    * Logger.
    */
   private Log log = ExoLogger.getLogger("exo.jcr.component.core.BaseImportTest");

   private final Random random = new Random();

   @Override
   public void initRepository() throws RepositoryException
   {
      super.initRepository();
      if (!isInitialized)
      {
         NodeTypeManagerImpl ntManager = (NodeTypeManagerImpl)session.getWorkspace().getNodeTypeManager();
         InputStream is = TestDocumentViewImport.class.getResourceAsStream("/nodetypes/ext-registry-nodetypes.xml");
         ntManager.registerNodeTypes(is, 0);
         ntManager.registerNodeTypes(TestDocumentViewImport.class
            .getResourceAsStream("/org/exoplatform/services/jcr/api/nodetypes/ecm/nodetypes-config.xml"), 0);
         ntManager.registerNodeTypes(TestDocumentViewImport.class
            .getResourceAsStream("/org/exoplatform/services/jcr/api/nodetypes/ecm/nodetypes-config-extended.xml"), 0);
         isInitialized = true;
      }
   }

   /**
    * Deserialize xml content to specific node from InputStream.
    * 
    * @param importRoot
    * @param saveType
    * @param isImportedByStream
    * @param uuidBehavior
    * @param is
    * @throws RepositoryException
    * @throws SAXException
    * @throws IOException
    */
   protected void deserialize(Node importRoot, XmlSaveType saveType, boolean isImportedByStream, int uuidBehavior,
      InputStream is) throws RepositoryException, SAXException, IOException
   {

      ExtendedSession extendedSession = (ExtendedSession)importRoot.getSession();
      ExtendedWorkspace extendedWorkspace = (ExtendedWorkspace)extendedSession.getWorkspace();
      if (isImportedByStream)
      {
         if (saveType == XmlSaveType.SESSION)
         {
            extendedSession.importXML(importRoot.getPath(), is, uuidBehavior);
         }
         else if (saveType == XmlSaveType.WORKSPACE)
         {
            extendedWorkspace.importXML(importRoot.getPath(), is, uuidBehavior);
         }

      }
      else
      {
         XMLReader reader = XMLReaderFactory.createXMLReader();
         if (saveType == XmlSaveType.SESSION)
         {
            reader.setContentHandler(extendedSession.getImportContentHandler(importRoot.getPath(), uuidBehavior));

         }
         else if (saveType == XmlSaveType.WORKSPACE)
         {
            reader.setContentHandler(extendedWorkspace.getImportContentHandler(importRoot.getPath(), uuidBehavior));
         }
         InputSource inputSource = new InputSource(is);

         reader.parse(inputSource);

      }
   }

   protected void executeSingeleThreadImportTests(int attempts, Class<? extends BeforeExportAction> firstAction,
      Class<? extends BeforeImportAction> secondAction, Class<? extends AfterImportAction> thirdAction)
      throws TransformerConfigurationException, IOException, RepositoryException, SAXException, InterruptedException
   {
      ExecutorService executor = Executors.newSingleThreadExecutor();
      executeImportTests(executor, attempts, firstAction, secondAction, thirdAction);
      executor.shutdown();
   }

   protected void executeMultiThreadImportTests(int threadCount, int attempts,
      Class<? extends BeforeExportAction> firstAction, Class<? extends BeforeImportAction> secondAction,
      Class<? extends AfterImportAction> thirdAction) throws TransformerConfigurationException, IOException,
      RepositoryException, SAXException, InterruptedException
   {
      ExecutorService executor = Executors.newCachedThreadPool();
      executeImportTests(executor, attempts, firstAction, secondAction, thirdAction);
      executor.shutdown();
   }

   /**
    * boolean isExportedByStream, boolean isImportedByStream, boolean
    * isSystemViewExport
    * 
    * @param firstAction
    * @param secondAction
    * @param thirdAction
    * @throws TransformerConfigurationException
    * @throws IOException
    * @throws RepositoryException
    * @throws SAXException
    * @throws InterruptedException
    */
   private void executeImportTests(ExecutorService executor, int attempts,
      Class<? extends BeforeExportAction> firstAction, Class<? extends BeforeImportAction> secondAction,
      Class<? extends AfterImportAction> thirdAction) throws TransformerConfigurationException, IOException,
      RepositoryException,

      SAXException, InterruptedException
   {
      XmlSaveType[] posibleSaveTypes = new XmlSaveType[]{XmlSaveType.SESSION, XmlSaveType.WORKSPACE};

      int[] posibleImportUUIDBehaviors =
         new int[]{ImportUUIDBehavior.IMPORT_UUID_COLLISION_REMOVE_EXISTING,
            ImportUUIDBehavior.IMPORT_UUID_COLLISION_REPLACE_EXISTING, ImportUUIDBehavior.IMPORT_UUID_COLLISION_THROW,
            ImportUUIDBehavior.IMPORT_UUID_CREATE_NEW};

      boolean[] posibleExportedByStream = new boolean[]{true, false};
      boolean[] posibleImportedByStream = new boolean[]{true, false};
      boolean[] posibleSystemViewExport = new boolean[]{true, false};

      Collection<Callable<XmlTestResult>> tasks = new ArrayList<Callable<XmlTestResult>>();
      List<Session> sessions = new ArrayList<Session>();
      for (int z = 0; z < attempts; z++)
      {

         for (int i = 0; i < posibleSaveTypes.length; i++)
         {
            for (int j = 0; j < posibleImportUUIDBehaviors.length; j++)
            {
               for (int j2 = 0; j2 < posibleExportedByStream.length; j2++)
               {
                  for (int k = 0; k < posibleImportedByStream.length; k++)
                  {
                     for (int k2 = 0; k2 < posibleSystemViewExport.length; k2++)
                     {
                        BeforeExportAction be;
                        BeforeImportAction bi;
                        AfterImportAction ai;
                        try
                        {

                           Session testSession = repository.login(credentials);
                           String testRootName = IdGenerator.generate();
                           Node testRoot = testSession.getRootNode().addNode(testRootName);
                           testSession.save();

                           be = ((BeforeExportAction)initImportExportAction(firstAction, testSession, testRoot));
                           bi = ((BeforeImportAction)initImportExportAction(secondAction, testSession, testRoot));
                           ai = ((AfterImportAction)initImportExportAction(thirdAction, testSession, testRoot));

                           if (testSession.getRootNode().hasNode(testRootName))
                           {
                              testSession.getRootNode().getNode(testRootName).remove();
                              testSession.save();

                           }

                           sessions.add(testSession);
                        }
                        catch (IllegalArgumentException e)
                        {
                           throw new RepositoryException(e);
                        }
                        catch (InstantiationException e)
                        {
                           throw new RepositoryException(e);
                        }
                        catch (IllegalAccessException e)
                        {
                           throw new RepositoryException(e);
                        }
                        catch (InvocationTargetException e)
                        {
                           throw new RepositoryException(e);
                        }

                        tasks.add(new XmlTestTask<XmlTestResult>(be, bi, ai, posibleSaveTypes[i],
                           posibleImportUUIDBehaviors[j], posibleExportedByStream[j2], posibleImportedByStream[k],
                           posibleSystemViewExport[k2]));

                     }
                  }
               }

            }
         }
      }
      executor.invokeAll(tasks);
      for (Session testSession : sessions)
      {
         testSession.logout();
      }
   }

   /**
    * Serialize content of MIX_REFERENCEABLE_NODE_NAME to byte array.
    * 
    * @param rootNode
    * @param isSystemView
    * @param isStream
    * @return
    * @throws IOException
    * @throws RepositoryException
    * @throws SAXException
    * @throws TransformerConfigurationException
    */
   protected byte[] serialize(Node exportRootNode, boolean isSystemView, boolean isStream) throws IOException,
      RepositoryException, SAXException, TransformerConfigurationException
   {

      ExtendedSession extendedSession = (ExtendedSession)exportRootNode.getSession();

      ByteArrayOutputStream outStream = new ByteArrayOutputStream();

      if (isSystemView)
      {

         if (isStream)
         {
            extendedSession.exportSystemView(exportRootNode.getPath(), outStream, false, false);
         }
         else
         {
            SAXTransformerFactory saxFact = (SAXTransformerFactory)TransformerFactory.newInstance();
            TransformerHandler handler = saxFact.newTransformerHandler();
            handler.setResult(new StreamResult(outStream));
            extendedSession.exportSystemView(exportRootNode.getPath(), handler, false, false);
         }
      }
      else
      {
         if (isStream)
         {
            extendedSession.exportDocumentView(exportRootNode.getPath(), outStream, false, false);
         }
         else
         {
            SAXTransformerFactory saxFact = (SAXTransformerFactory)TransformerFactory.newInstance();
            TransformerHandler handler = saxFact.newTransformerHandler();
            handler.setResult(new StreamResult(outStream));
            extendedSession.exportDocumentView(exportRootNode.getPath(), handler, false, false);
         }
      }
      outStream.close();
      return outStream.toByteArray();
   }
   
   /**
    * Serialize content of MIX_REFERENCEABLE_NODE_NAME to file.
    * 
    * @param rootNode
    * @param isSystemView
    * @param isStream
    * @return
    * @throws IOException
    * @throws RepositoryException
    * @throws SAXException
    * @throws TransformerConfigurationException
    */
   protected File serializeToFile(Node exportRootNode, boolean isSystemView, boolean isStream) throws IOException,
                                                                                          RepositoryException,
                                                                                          SAXException,
                                                                                          TransformerConfigurationException {

     ExtendedSession extendedSession = (ExtendedSession) exportRootNode.getSession();

     File file = File.createTempFile("export", ".xml");
     
     FileOutputStream outStream = new FileOutputStream(file);

     if (isSystemView) {

       if (isStream) {
         extendedSession.exportSystemView(exportRootNode.getPath(), outStream, false, false);
       } else {
         SAXTransformerFactory saxFact = (SAXTransformerFactory) TransformerFactory.newInstance();
         TransformerHandler handler = saxFact.newTransformerHandler();
         handler.setResult(new StreamResult(outStream));
         extendedSession.exportSystemView(exportRootNode.getPath(), handler, false, false);
       }
     } else {
       if (isStream) {
         extendedSession.exportDocumentView(exportRootNode.getPath(), outStream, false, false);
       } else {
         SAXTransformerFactory saxFact = (SAXTransformerFactory) TransformerFactory.newInstance();
         TransformerHandler handler = saxFact.newTransformerHandler();
         handler.setResult(new StreamResult(outStream));
         extendedSession.exportDocumentView(exportRootNode.getPath(), handler, false, false);
       }
     }
     outStream.close();
     return file;
   }

   protected void serialize(Node rootNode, boolean isSystemView, boolean isStream, File content) throws IOException,
      RepositoryException, SAXException, TransformerConfigurationException
   {
      ExtendedSession extendedSession = (ExtendedSession)rootNode.getSession();

      OutputStream outStream = new FileOutputStream(content);
      if (isSystemView)
      {

         if (isStream)
         {
            extendedSession.exportSystemView(rootNode.getPath(), outStream, false, false);
         }
         else
         {
            SAXTransformerFactory saxFact = (SAXTransformerFactory)TransformerFactory.newInstance();
            TransformerHandler handler = saxFact.newTransformerHandler();
            handler.setResult(new StreamResult(outStream));
            extendedSession.exportSystemView(rootNode.getPath(), handler, false, false);
         }
      }
      else
      {
         if (isStream)
         {
            extendedSession.exportDocumentView(rootNode.getPath(), outStream, false, false);
         }
         else
         {
            SAXTransformerFactory saxFact = (SAXTransformerFactory)TransformerFactory.newInstance();
            TransformerHandler handler = saxFact.newTransformerHandler();
            handler.setResult(new StreamResult(outStream));
            extendedSession.exportDocumentView(rootNode.getPath(), handler, false, false);
         }
      }
      outStream.close();

   }

   private ImportExportAction initImportExportAction(final Class<? extends ImportExportAction> importExportAction,
      final Session initSession, final Node testRoot) throws IllegalArgumentException, InstantiationException,
      IllegalAccessException, InvocationTargetException
   {

      Constructor<?>[] constructors = importExportAction.getDeclaredConstructors();

      Constructor<? extends ImportExportAction> constructor = null;
      for (int i = 0; i < constructors.length; i++)
      {
         if (constructors[i].getParameterTypes().length > 1)
            constructor = (Constructor<? extends ImportExportAction>)constructors[i];
      }

      ImportExportAction action = constructor.newInstance(new Object[]{this, initSession, testRoot});
      return action;
   }

   protected abstract class AfterImportAction extends ImportExportAction
   {

      public AfterImportAction(Session session, Node testRootNode) throws RepositoryException
      {
         super(session, testRootNode);
      }

      @Override
      public void cleanUp() throws RepositoryException
      {
         session.refresh(false);
         Node rootNode = session.getRootNode();
         if (rootNode.hasNodes())
         {
            // clean test root
            for (NodeIterator children = rootNode.getNodes(); children.hasNext();)
            {
               Node node = children.nextNode();
               if (!node.getPath().startsWith("/jcr:system"))
               {
                  // log.info("DELETing ------------- "+node.getPath());
                  node.remove();
               }
            }
            session.save();

         }
      }
   }

   protected abstract class BeforeExportAction extends ImportExportAction
   {

      public BeforeExportAction(Session session, Node testRootNode) throws RepositoryException
      {
         super(session, testRootNode);
      }

      public abstract Node getExportRoot() throws RepositoryException;
   }

   protected abstract class BeforeImportAction extends ImportExportAction
   {

      public BeforeImportAction(Session session, Node testRootNode) throws RepositoryException
      {
         super(session, testRootNode);
      }

      public abstract Node getImportRoot() throws RepositoryException;
   }

   protected abstract class ImportExportAction
   {

      protected final Node testRootNode;

      protected final Session testSession;

      public ImportExportAction(Session testSession, Node testRootNode) throws RepositoryException
      {
         super();
         this.testSession = testSession;
         this.testRootNode = testRootNode;
      }

      public void cleanUp() throws RepositoryException
      {

      };

      public void execute() throws RepositoryException
      {
      }

   }

   private class XmlTestTask<XmlTestResult> implements Callable<XmlTestResult>
   {

      private final BeforeExportAction firstAction;

      private final XmlSaveType importSaveType;

      private final int importUUIDBehavior;

      private final boolean isExportedByStream;

      private final boolean isImportedByStream;

      private final boolean isSystemViewExport;

      private final BeforeImportAction secondAction;

      private final AfterImportAction thirdAction;

      public XmlTestTask(BeforeExportAction firstAction, BeforeImportAction secondAction,
         AfterImportAction thirdAction, XmlSaveType importSaveType, int importUUIDBehavior, boolean isExportedByStream,
         boolean isImportedByStream, boolean isSystemViewExport)
      {
         super();
         this.firstAction = firstAction;
         this.secondAction = secondAction;
         this.thirdAction = thirdAction;
         this.importSaveType = importSaveType;
         this.importUUIDBehavior = importUUIDBehavior;
         this.isExportedByStream = isExportedByStream;
         this.isImportedByStream = isImportedByStream;
         this.isSystemViewExport = isSystemViewExport;

      }

      public XmlTestResult call() throws Exception
      {
         if (log.isDebugEnabled())
            log.debug("isSys=" + isSystemViewExport + "\t" + "isES=" + isExportedByStream + "\t" + "importST="
               + importSaveType.toString() + "\t" + "isIS=" + isImportedByStream + "\t" + "importBehavior="
               + importUUIDBehavior + "\t");
         firstAction.execute();
         firstAction.cleanUp();

         byte[] buf = serialize(firstAction.getExportRoot(), isSystemViewExport, isExportedByStream);

         secondAction.execute();
         secondAction.cleanUp();

         Node importRoot = secondAction.getImportRoot();
         Exception resultException = null;
         try
         {
            deserialize(importRoot, importSaveType, isImportedByStream, importUUIDBehavior, new ByteArrayInputStream(
               buf));
            if (importSaveType.equals(XmlSaveType.SESSION))
               importRoot.getSession().save();
         }
         catch (RepositoryException e)
         {
            resultException = e;
         }
         catch (SAXException e)
         {
            resultException = e;
         }
         if (resultException != null && importUUIDBehavior != ImportUUIDBehavior.IMPORT_UUID_COLLISION_THROW)
         {

            if (resultException instanceof RepositoryException)
               throw (RepositoryException)resultException;
            else if (resultException instanceof SAXException)
               throw (SAXException)resultException;

         }

         thirdAction.execute();
         thirdAction.cleanUp();

         return null;
      }

   }

   public class XmlTestResult
   {

   }
}
