/*******************************************************************************
    * Copyright 2012 pw999
    * 
    * 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.
   ******************************************************************************/
  package net.sf.oqt.jpa;
  
  import java.lang.reflect.Field;
  import java.sql.SQLException;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  
  import javax.persistence.EntityManager;
  import javax.persistence.Query;
  
  import net.sf.oqt.core.CoreFactory;
  import net.sf.oqt.driver.NullDriver;
  import net.sf.oqt.model.EntityVO;
  import net.sf.oqt.model.PackageVO;
  import net.sf.oqt.model.QueryType;
  import net.sf.oqt.model.QueryVO;
  
  import org.apache.openjpa.kernel.DelegatingQuery;
  import org.apache.openjpa.persistence.OpenJPAQuery;
  
  
  /**
   * This class does all the calls to openJPA to get the SQL query using the {@link NullDriver} and {@link NullConnection}
   * 
   * @author phillip
   * 
   */
  public class JPATransformer {
  
      /**
       * Transforms all the JPQL queries to SQL queries.
       * 
       * @param packages the initialized set of PackageVO's. Ideally the output from the
       *            {@link EntityFinder#findAllEntities(Set)} method.
       * @throws ClassNotFoundException
       * @throws InstantiationException
       * @throws IllegalAccessException
       * @throws SQLException
       */
      public static final void transformAllQueries(final Collection<PackageVO> packages) throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
          final Iterator<PackageVO> packIt = packages.iterator();
          while (packIt.hasNext()) {
              final PackageVO pack = packIt.next();
              final Iterator<EntityVO> entIt = pack.getEntities().iterator();
              while (entIt.hasNext()) {
                  final EntityVO ent = entIt.next();
                  final Iterator<QueryVO> qIt = ent.getQueries().iterator();
                  while (qIt.hasNext()) {
                      final QueryVO q = qIt.next();
                      transform(q);
                  }
              }
          }
      }
  
      public static final void validateOnly(final Collection<PackageVO> packages) throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
          final Iterator<PackageVO> packIt = packages.iterator();
          while (packIt.hasNext()) {
              final PackageVO pack = packIt.next();
              final Iterator<EntityVO> entIt = pack.getEntities().iterator();
              while (entIt.hasNext()) {
                  final EntityVO ent = entIt.next();
                  final Iterator<QueryVO> qIt = ent.getQueries().iterator();
                  while (qIt.hasNext()) {
                      final QueryVO q = qIt.next();
                      validate(q);
                  }
              }
          }
      }
  
      @SuppressWarnings("rawtypes")
      static final void validate(final QueryVO queryVO) throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
          final EntityManager em = CoreFactory.getEntityManager();
          try {
              final Query q = em.createQuery(queryVO.getJPQLQuery());
              ((OpenJPAQuery) q).compile();
          } catch (final Throwable t) {
              queryVO.setError(t);
              return;
          }
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
     static final void transform(final QueryVO queryVO) throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
         CoreFactory.getQueries().clear();
         final EntityManager em = CoreFactory.getEntityManager();
         Query q = null;
         try {
             q = em.createQuery(queryVO.getJPQLQuery()); // openJPA 2.x throws validation exception here
             ((OpenJPAQuery) q).compile(); // openJPA 1.x needs manual validation
         } catch (final Throwable t) {
             queryVO.setError(t);
             return;
         }
         Field field;
         try {
             field = q.getClass().getDeclaredField("_query");
             field.setAccessible(true);
             final DelegatingQuery dq = (DelegatingQuery) field.get(q);
             final Map<String, Class<?>> params = dq.getParameterTypes();
             final Set<Entry<String, Class<?>>> entrySet = params.entrySet();
             for (final Entry<String, Class<?>> entry : entrySet) {
                 q.setParameter(entry.getKey(), ParameterFactory.intialize(entry.getValue()));
             }
         } catch (SecurityException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (NoSuchFieldException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         final QueryType type = QueryType.getTypeFromJPQL(queryVO.getJPQLQuery());
         try {
             if (type.equals(QueryType.SELECT)) {
                 q.getResultList();
             } else {
                 em.getTransaction().begin();
                 q.executeUpdate();
                 em.getTransaction().rollback();
             }
         } catch (final Throwable t) {
             queryVO.setError(t);
             return;
         }
         queryVO.getSQLQuery().addAll(CoreFactory.getQueries());
     }
 
 }