/*

  * Copyright 2005-2007 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.rice.kew.doctype.dao.impl;

 import org.apache.log4j.Logger;

 import org.apache.ojb.broker.PersistenceBroker;

 import org.apache.ojb.broker.query.Criteria;

 import org.apache.ojb.broker.query.QueryByCriteria;

 import org.apache.ojb.broker.query.QueryFactory;

 import org.apache.ojb.broker.query.ReportQueryByCriteria;

 import org.kuali.rice.kew.doctype.DocumentTypeAttribute;

 import org.kuali.rice.kew.doctype.bo.DocumentType;

 import org.kuali.rice.kew.doctype.dao.DocumentTypeDAO;

 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;

 import org.kuali.rice.kew.rule.bo.RuleAttribute;

 import org.kuali.rice.kew.util.Utilities;

 import org.springmodules.orm.ojb.OjbFactoryUtils;

 import org.springmodules.orm.ojb.support.PersistenceBrokerDaoSupport;

 import java.math.BigDecimal;

 import java.sql.Connection;

 import java.sql.ResultSet;

 import java.sql.Statement;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Iterator;

 import java.util.List;

 public class DocumentTypeDAOOjbImpl extends PersistenceBrokerDaoSupport implements DocumentTypeDAO {

         public static final Logger LOG = Logger.getLogger(DocumentTypeDAOOjbImpl.class);

         public void delete(DocumentType documentType) {

                 this.getPersistenceBrokerTemplate().delete(documentType);

         }

         public DocumentType findByDocId(Long docId) {

                 Criteria crit = new Criteria();

                 crit.addEqualTo("documentTypeId", docId);

                 return (DocumentType) this.getPersistenceBrokerTemplate().getObjectByQuery(new QueryByCriteria(DocumentType.class, crit));

         }

         public DocumentType findByName(String name) {

                 return findByName(name, true);

         }

         public DocumentType findByName(String name, boolean caseSensitive) {

                 Criteria crit = new Criteria();

                 if(!caseSensitive){

                         crit.addEqualTo("UPPER(name)", name.trim().toUpperCase());

                 }else{

                         crit.addEqualTo("name", name);

                 }

                 crit.addEqualTo("currentInd", Boolean.TRUE);

                 DocumentType docType = (DocumentType) this.getPersistenceBrokerTemplate().getObjectByQuery(new QueryByCriteria(DocumentType.class, crit));

                 return docType;

         }

         public Integer getMaxVersionNumber(String docTypeName) {

                 return getMostRecentDocType(docTypeName).getVersion();

         }

         public List getChildDocumentTypeIds(Long parentDocumentTypeId) {

                 List<Long> childrenIds = new ArrayList<Long>();

                 PersistenceBroker broker = getPersistenceBroker(false);

                 Connection conn = null;

                 Statement st = null;

                 ResultSet rs = null;

                 try {

                         conn = broker.serviceConnectionManager().getConnection();

                         st = conn.createStatement();

                         rs = st.executeQuery("select DOC_TYP_ID from KREW_DOC_TYP_T where CUR_IND = 1 and PARNT_ID = " + parentDocumentTypeId);

                         while (rs.next()) {

                                 childrenIds.add(new Long(rs.getLong("DOC_TYP_ID")));

                         }

                 } catch (Exception e) {

                         LOG.error("Error occured fetching children document type ids for document type " + parentDocumentTypeId, e);

                         throw new RuntimeException(e);

                 } finally {

                         try {

                                 st.close();

                         } catch (Exception e) {

                                 LOG.warn("Failed to close Statement", e);

                         }

                         try {

                                 rs.close();

                         } catch (Exception e) {

                                 LOG.warn("Failed to close Resultset", e);

                         }

                 if (broker != null) {

                         try {

                                 OjbFactoryUtils.releasePersistenceBroker(broker, this.getPersistenceBrokerTemplate().getPbKey());

                         } catch (Exception e) {

                                 LOG.error("Failed closing connection: " + e.getMessage(), e);

                         }

                 }

                 }

                 return childrenIds;

         }

         public DocumentType getMostRecentDocType(String docTypeName) {

                 Criteria crit = new Criteria();

                 crit.addEqualTo("name", docTypeName);

                 QueryByCriteria query = new QueryByCriteria(DocumentType.class, crit);

                 query.addOrderByDescending("version");

                 Iterator docTypes = this.getPersistenceBrokerTemplate().getCollectionByQuery(query).iterator();

                 while (docTypes.hasNext()) {

                         return (DocumentType) docTypes.next();

                 }

                 return null;

         }

         public void save(DocumentType documentType) {

                 this.getPersistenceBrokerTemplate().store(documentType);

         }

         public List findByRouteHeaderId(Long routeHeaderId) {

                 Criteria crit = new Criteria();

                 crit.addEqualTo("routeHeaderId", routeHeaderId);

                 return (List) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(DocumentType.class, crit));

         }

         public Collection<DocumentType> find(DocumentType documentType, DocumentType docTypeParent, boolean climbHierarchy) {

                 LOG.debug("documentType: "+ documentType);

                 LOG.debug("docTypeParent: "+ docTypeParent);

                 LOG.debug("climbHierarchy: " + climbHierarchy);

                 Criteria crit = new Criteria();

                 if (documentType != null && !Utilities.isEmpty(documentType.getLabel())) {

                         crit.addLike("UPPER(label)", documentType.getLabel().trim().toUpperCase());

                 }

                 if (documentType != null && !Utilities.isEmpty(documentType.getName())) {

                         String docTypeName = documentType.getName();

                         crit.addLike("UPPER(name)", ("%" + docTypeName.trim() + "%").toUpperCase());

                 }

                 if (documentType != null && documentType.getActive() != null) {

                         crit.addEqualTo("active", documentType.getActive());

                 }

                 if (documentType != null && documentType.getDocumentTypeId() != null) {

                         crit.addEqualTo("documentTypeId", documentType.getDocumentTypeId());

                 }

                 if (documentType != null && documentType.getActualServiceNamespace() != null){

                         crit.addEqualTo("actualServiceNamespace", documentType.getActualServiceNamespace());

                 }

                 if (docTypeParent != null) {

                         if (!"".equals(docTypeParent.getName()) && docTypeParent.getName() != null) {

                                 Criteria parentCrit = new Criteria();

                                 //addParentNameOrCriteria(docTypeParent.getName(), parentCrit);

                                 addParentIdOrCriteria(docTypeParent.getDocumentTypeId(), parentCrit);

                                 if (climbHierarchy) {

                                         assembleChildrenCriteria(docTypeParent.getChildrenDocTypes(), parentCrit);

                                 }

                                 parentCrit.addEqualTo("currentInd", Boolean.TRUE);

                                 crit.addAndCriteria(parentCrit);

                         }

                 } else {

                         if (documentType != null && !Utilities.isEmpty(documentType.getName())) {

                                 DocumentType searchDocumentType = findByName(documentType.getName());

                                 if ((searchDocumentType != null) && climbHierarchy) {

                                         LOG.debug("searchDocumentType: "+ searchDocumentType);

                                         Criteria criteria = new Criteria();

                                         //addParentNameOrCriteria(searchDocumentType.getName(), criteria);

                     addParentIdOrCriteria(searchDocumentType.getDocumentTypeId(), criteria);

                     assembleChildrenCriteria(searchDocumentType.getChildrenDocTypes(), criteria);

                                         criteria.addEqualTo("currentInd", Boolean.TRUE);

                                         crit.addOrCriteria(criteria);

                                 }

                         }

                 }

                 crit.addEqualTo("currentInd", Boolean.TRUE);

                 return (Collection<DocumentType>) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(DocumentType.class, crit));

         }

     private void addParentIdOrCriteria(Long parentId, Criteria mainCriteria) {

         Criteria parentCriteria = new Criteria();

         parentCriteria.addEqualTo("docTypeParentId", parentId);

         mainCriteria.addOrCriteria(parentCriteria);

     }

         private void assembleChildrenCriteria(Collection childrenDocTypes, Criteria crit) {

                 if (childrenDocTypes != null) {

                         Iterator childrenDocTypesIter = childrenDocTypes.iterator();

                         while (childrenDocTypesIter.hasNext()) {

                                 DocumentType child = (DocumentType) childrenDocTypesIter.next();

                                 addParentIdOrCriteria(child.getDocumentTypeId(), crit);

                                 assembleChildrenCriteria(child.getChildrenDocTypes(), crit);

                         }

                 }

         }

         public DocumentType getMostRecentDocType(Long documentTypeId) {

                 Criteria crit = new Criteria();

                 crit.addEqualTo("documentTypeId", documentTypeId);

                 QueryByCriteria query = new QueryByCriteria(DocumentType.class, crit);

                 query.addOrderByDescending("version");

                 Iterator docTypes = this.getPersistenceBrokerTemplate().getCollectionByQuery(query).iterator();

                 while (docTypes.hasNext()) {

                         return (DocumentType) docTypes.next();

                 }

                 return null;

         }

         public List findAllCurrentRootDocuments() {

                 Criteria crit = new Criteria();

                 crit.addIsNull("docTypeParentId");

                 return findAllCurrent(crit);

         }

     public List findAllCurrent() {

         return findAllCurrent(new Criteria());

     }

     public List findAllCurrentByName(String name) {

         Criteria crit = new Criteria();

         crit.addEqualTo("name", name);

         return findAllCurrent(crit);

     }

     public List<DocumentType> findPreviousInstances(String documentTypeName) {

         Criteria crit = new Criteria();

         crit.addEqualTo("name", documentTypeName);

         crit.addEqualTo("currentInd", Boolean.FALSE);

         return findAll(crit);

     }

     private List<DocumentType> findAllCurrent(Criteria crit) {

         crit.addEqualTo("currentInd", Boolean.TRUE);

         return findAll(crit);

     }

     private List<DocumentType> findAll(Criteria crit) {

         return (List<DocumentType>) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(DocumentType.class, crit));

     }

     public List findDocumentTypeAttributes(RuleAttribute ruleAttribute) {

             Criteria crit = new Criteria();

             crit.addEqualTo("ruleAttributeId", ruleAttribute.getRuleAttributeId());

             return (List) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(DocumentTypeAttribute.class, crit));

     }

     public Long findDocumentTypeIdByDocumentId(Long documentId) {

             Criteria crit = new Criteria();

             crit.addEqualTo("routeHeaderId", documentId);

             ReportQueryByCriteria query = QueryFactory.newReportQuery(DocumentRouteHeaderValue.class, crit);

             query.setAttributes(new String[] { "documentTypeId" });

             Iterator iter = getPersistenceBrokerTemplate().getReportQueryIteratorByQuery(query);

             while (iter.hasNext()) {

                 Object[] row = (Object[]) iter.next();

                 BigDecimal id = (BigDecimal)row[0];

                 return new Long(id.longValue());

             }

             return null;

     }

 }