/*
    * Copyright 2011 The Kuali Foundation.
    * 
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    * 
   * 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.kuali.ole;
  
  import org.apache.commons.io.FileUtils;
  import org.junit.Before;
  import org.junit.Test;
  import org.kuali.ole.docstore.model.enums.DocCategory;
  import org.kuali.ole.docstore.model.enums.DocFormat;
  import org.kuali.ole.docstore.model.enums.DocType;
  import org.kuali.ole.docstore.model.repopojo.FolderNode;
  import org.kuali.ole.docstore.model.repopojo.RepositoryData;
  import org.kuali.ole.docstore.model.xmlpojo.ingest.Request;
  import org.kuali.ole.docstore.model.xmlpojo.ingest.Response;
  import org.kuali.ole.docstore.model.xstream.ingest.RequestHandler;
  import org.kuali.ole.docstore.service.BeanLocator;
  import org.kuali.ole.docstore.service.IngestNIndexHandlerService;
  import org.kuali.ole.pojo.OleException;
  import org.mockito.MockitoAnnotations;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import java.io.File;
  import java.net.URL;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import static junit.framework.Assert.assertNotNull;
  import static org.junit.Assert.assertTrue;
  
  /**
   * Created by IntelliJ IDEA.
   * User: peris
   * Date: 5/23/11
   * Time: 10:20 AM
   * To change this template use File | Settings | File Templates.
   */
  public class RepositoryBrowser_UT
          extends BaseTestCase {
  
      private static final Logger                     LOG                        = LoggerFactory
              .getLogger(RepositoryBrowser_UT.class);
      private              IngestNIndexHandlerService ingestNIndexHandlerService = BeanLocator
              .getIngestNIndexHandlerService();
  
      @Before
      public void setUp() throws Exception {
          super.setUp();
          MockitoAnnotations.initMocks(this);
      }
  
      @Test
      public void testBrowseRepository() throws Exception {
          RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
          List<OleDocStoreData> oleDocStoreDatas = repositoryBrowser.browseDataSetup();
          for (Iterator<OleDocStoreData> iterator = oleDocStoreDatas.iterator(); iterator.hasNext(); ) {
              OleDocStoreData oleDocStoreData = iterator.next();
              LOG.info(oleDocStoreData.getCategory());
              Map<String, List<String>> typeFormatMap = oleDocStoreData.getTypeFormatMap();
              Set<String> keys = typeFormatMap.keySet();
              for (Iterator<String> stringIterator = keys.iterator(); stringIterator.hasNext(); ) {
                  String docType = stringIterator.next();
                  LOG.info(docType + ": " + typeFormatMap.get(docType));
              }
          }
      }
  
      @Test
      public void testGetRandomUUIDs() throws Exception {
          URL url = this.getClass().getResource("repository/request.xml");
          File file = new File(url.toURI());
  
          String docStoreDocuments = ingestNIndexHandlerService.ingestNIndexRequestDocuments(readFile(file));
          assertTrue(!docStoreDocuments.isEmpty());
          RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
          List<String> uuiDs = repositoryBrowser
                  .getUUIDs(DocCategory.WORK.getCode(), DocType.BIB.getDescription(), DocFormat.MARC.getCode(), 1);
          assertTrue(!uuiDs.isEmpty());
          for (Iterator<String> iterator = uuiDs.iterator(); iterator.hasNext(); ) {
              String uuid = iterator.next();
              LOG.info(uuid);
         }
     }
 
     @Test
     public void testRepositoryNodeCount() throws Exception {
         // MarcIngester marcIngester = new MarcIngester();
         // marcIngester.setSolrIndexer(mockSolrIndexer);
         // URL url = this.getClass().getResource("sample.xml");
         // File file = new File(url.toURI());
         // List<RequestDocument> docStoreDocuments = marcIngester.ingestDocument(readFile(file));
         // assertTrue(!docStoreDocuments.isEmpty());
 
         RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
         List<OleDocStoreData> oleDocStoreDataList = repositoryBrowser.getFilesCount();
         assertNotNull(oleDocStoreDataList);
         for (Iterator<OleDocStoreData> iterator = oleDocStoreDataList.iterator(); iterator.hasNext(); ) {
             OleDocStoreData oleDocStoreData = iterator.next();
             Map<String, Map<String, Long>> typeFormatMapWithNodeCount = oleDocStoreData.getTypeFormatMapWithNodeCount();
             for (Iterator<String> oleDocStoreDataIterator = typeFormatMapWithNodeCount.keySet()
                                                                                       .iterator(); oleDocStoreDataIterator
                     .hasNext(); ) {
                 String key = oleDocStoreDataIterator.next();
                 LOG.info(key + ": " + typeFormatMapWithNodeCount.get(key));
             }
         }
     }
 
     @Test
     public void repoDump() throws RepositoryException, OleException {
         RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
         String dump = repositoryBrowser.getRepositoryDump();
         LOG.info("dump" + dump);
     }
 
     @Test
     public void getRepositoryDumpRange() throws Exception {
         RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
         String category = DocCategory.WORK.getCode();
         String type = DocType.BIB.getDescription();
         String format = DocFormat.MARC.getCode();
         int fromIndex = 1;
         int Count = 1;
         cleanRepository(category, type);
         String beforedump = repositoryBrowser.getRepositoryDump();
         LOG.info("beforedump" + beforedump);
         loadBulkMarcRecords(DocCategory.WORK.getCode(), DocType.BIB.getDescription(), DocFormat.MARC.getCode(),
                             "/org/kuali/ole/bulkhandler/OLE-Bib-bulkIngest-IU-Set1-split.xml");
         String dump = repositoryBrowser.getRepositoryDump();
         LOG.info("dump" + dump);
         String dumpRange = repositoryBrowser.getRepositoryRangeDump(category, type, format, fromIndex, Count);
         LOG.info("dumpRange" + dumpRange);
     }
 
     public void cleanRepository(String category, String type) throws OleException, RepositoryException {
         RepositoryManager repositoryManager = RepositoryManager.getRepositoryManager();
         Session session = repositoryManager.getSession("mockUser", "test");
         Node rootNode = session.getRootNode();
         Node catNode = rootNode.getNode(category);
         Node typeNode = catNode.getNode(type);
         for (Iterator<Node> typeiterator = typeNode.getNodes(); typeiterator.hasNext(); ) {
             Node formatNode = typeiterator.next();
             if (!formatNode.getName().equals("jcr:system")) {
                 formatNode.remove();
             }
         }
         session.save();
         repositoryManager.logout(session);
     }
 
     private void loadBulkMarcRecords(String category, String type, String format, String inputXml) throws Exception {
         File file = new File(getClass().getResource("/org/kuali/ole/repository/request.xml").toURI());
         String input = FileUtils.readFileToString(file);
         RequestHandler rh = new RequestHandler();
         Request request = rh.toObject(input);
         Response response = ingestNIndexHandlerService.ingestNIndexRequestDocuments(request);
 
         // BulkLoadHandler bulkLoadHandler = new BulkLoadHandler();
         // assertNotNull(bulkLoadHandler);
         // List<String> recordUUIDs = bulkLoadHandler.loadBulk(category,
         // type,
         // format,
         // new File(getClass().getResource(inputXml).toURI()),
         // "testUser", "testLoadBulk");
         // assertNotNull(recordUUIDs);
         // Assert.assertTrue(!recordUUIDs.isEmpty());
         // for (Iterator<String> iterator = recordUUIDs.iterator(); iterator.hasNext(); ) {
         // String recordUUID = iterator.next();
         // LOG.info("recordUUID"+recordUUID);
         // }
     }
 
     @Test
     public void loadRepository() throws OleException, RepositoryException {
         RepositoryManager oleRepositoryManager = RepositoryManager.getRepositoryManager();
         RepositoryData repositoryData = new RepositoryData();
         RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
         FolderNode folderNode = repositoryBrowser
                 .computeNodeCount(oleRepositoryManager.getSession().getRootNode(), repositoryData);
         String repoDump = repositoryData.getRepositoryDump(repositoryData);
         LOG.info("repoDump" + repoDump);
     }
 
 }