/*

  * Copyright 2006 Outsource Cafe, Inc.

  *

  * 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 org.javagen.revgen.visitor;

 import org.javagen.agile.db.model.Cardinality;

 import org.javagen.agile.db.model.Column;

 import org.javagen.agile.db.model.FkConstraint;

 import org.javagen.agile.db.model.Table;

 import org.javagen.agile.oo.model.Class;

 import org.javagen.agile.oo.model.Reference;

 import org.javagen.revgen.context.Keys;

 /**

  * Traverses the database model in two steps and generates an entity model.

  * <ol>

  * <li>The first pass generates classes and properties from tables and columns.</li>

  * <li>The second pass generates references from foreign key constraints.</li>

  * </ol>

  * Having two passes allows the model to be more easily manipulated between passes 

  * before data (ie names) are duplicated.

  * 

  * @author Richard Easterling

  */

 public class DbTransformerPass2 extends DbTransformerPass1 {

     private static org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(DbTransformerPass2.class);

         // /////////////////////////////////////////////////////////////////////////

         // DatabaseModelVisitor interface methods:

         // /////////////////////////////////////////////////////////////////////////

     public DbTransformerPass2() {

         this.setItinerary(new String[] {FkConstraint.DEFAULT_MODEL_TYPE});

     }

     /** 

      * Convert foreign key constraint into class reference.

      */

         public void visit(FkConstraint fkConstraint) { 

         assert fkConstraint.getParentTable() != null;

                 if (fkConstraint.getChildModels() != null) {

             if ( ! Boolean.TRUE.equals(fkConstraint.getParentTable().isLinkTable()) ) {

                 currentClass = (Class)fkConstraint.getParentTable().get(Keys.ENTITY.toString());

                 if (currentClass != null) {

                     contextLoader.pushAll(stack, fkConstraint);

                     try {

                         Cardinality cardinality = fkConstraint.getCardinality();

                         if (cardinality==null) {

                             fkConstraint.setCardinality( getDb2OOMapper().determineCardinality(fkConstraint) );

                         }

                         boolean toMany = getDb2OOMapper().isManyCardinality(fkConstraint);

                         Reference reference = new Reference();

                         String name = uniquePropertyName(currentClass, getDb2OOMapper().referenceName(fkConstraint) );

                         reference.setName(name);

                         Class type = getDb2OOMapper().referenceType(fkConstraint);

                         reference.setTargetType(type);

                         if (toMany) {

                             String collectionType = getDb2OOMapper().containerType(fkConstraint);

                             reference.setCollectionType(collectionType);

                         }

                         reference.setNavigable(true);

                         currentClass.addChildModel(reference);

                         reference.put(Keys.FK_CONSTRAINT.toString(), fkConstraint);

                         fkConstraint.put(Keys.REFERENCE.toString(), reference);

                         trySettingReverseReferences(fkConstraint, reference);

                         if (log.isDebugEnabled())

                             log.debug("created reference: "+reference);

                     } finally {

                         contextLoader.popAll(stack, fkConstraint);

                     }

                 }

             }

                 }

         }

     public void visit(Table table) { throw new java.lang.IllegalStateException("visit(Table) BAD - not supposed to be here"); }

     public void visit(Column column) { throw new java.lang.IllegalStateException("visit(Table) BAD - not supposed to be here"); }

         // /////////////////////////////////////////////////////////////////////////

         // helper methods:

         // /////////////////////////////////////////////////////////////////////////

    /** 

      * create links to reverse references on 2nd reference creation

      */

         private void trySettingReverseReferences(FkConstraint fkConstraint, Reference reference) {

         boolean isLinkTable = Boolean.TRUE.equals(fkConstraint.getTargetTable().isLinkTable());

         Reference reverse = null;

         FkConstraint reverseFkColumn = fkConstraint.getReverseFkConstraint();

         if (isLinkTable) {

             for(FkConstraint linkFkColumn : fkConstraint.getTargetTable().getFkColumns()) 

                 if (fkConstraint.getParentTable() != linkFkColumn.getTargetTable())

                     reverseFkColumn = linkFkColumn.getReverseFkConstraint();

         }

         reverse = (Reference)reverseFkColumn.get(Keys.REFERENCE.toString());

         if (reverse!=null && reverse.getReverse()==null) {

             if (isLinkTable || fkConstraint.getReverseFkConstraint().getReverseFkConstraint()==fkConstraint) {

                 reverse.setReverse(reference);

                 reference.setReverse(reverse);

             } else {

                 log.warn("Reverse reference not set for "+reference+" - foreign key may have multiple constraints.");

             }

         }

         }

 }