/*

  * 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 java.util.HashSet;

 import java.util.Set;

 import org.javagen.agile.core.model.Model;

 import org.javagen.agile.core.util.StringUtil;

 import org.javagen.agile.core.visitor.DefaultVisitor;

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

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

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

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

 import org.javagen.revgen.context.Keys;

 /**

  * Post-process DB-to-Java model before templates are generated, making sure model is consistant. 

  * Doing this in a seperate pass, allows changes to be made to the model

  * by intermediate processes (ie customized metadata).

  *

  * @author Richard Easterling

  */

 public class PostProcessVisitor extends DefaultVisitor {

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

     public PostProcessVisitor() {

         Set<String> itinerary = new HashSet<String>();

         itinerary.add(Reference.DEFAULT_MODEL_TYPE);

         this.setItinerary(itinerary);

     }

     @Override

     public void visit(Model model) {

         if (model instanceof Reference) {

             Reference reference = (Reference)model;

             referenceOwningSide(reference);

         }

     }

     /**

      * Determines the owning side of a relationship as follows:

      * <ol>

      * <li>if unidirectional then it IS the owning side</li>

      * <li>if is the foreign key holding side then it IS the owning side</li>

      * <li>if it is a ManyToMany and <code>owningSide=true</code> set in context then it IS the owning side</li>

      * <li>if it is a ManyToMany then sort parent tables by name to determine owning side</li>

      * </ol>

      * @param reference

      */

     protected void referenceOwningSide(Reference reference) {

         //needed values:

         Reference reverseReference = reference.getReverse();

         FkConstraint fkConstraint = (FkConstraint)reference.get(Keys.FK_CONSTRAINT.toString());

         FkConstraint reverseFkColumn = reverseReference==null ? null : (FkConstraint)reverseReference.get(Keys.FK_CONSTRAINT.toString());

         Object val = reference.get(Keys.OWNING_SIDE.toString());

         Boolean owningSideAlreadySet = val==null ? null : Boolean.parseBoolean(val.toString());//works with strings or booleans

         //sanity checks:

         if (reverseReference==null)

             warn(reference+" has no reverseReference set");

         if (fkConstraint==null)

             warn(reference+" has no 'fkColumn' set in context");

         if (reverseReference!=null && reverseFkColumn==null)

             warn(reverseReference+" has no 'fkColumn' set in context");

         boolean bidirectional = 

             reverseReference!=null 

             && ! Boolean.FALSE.equals(reverseReference.getNavigable())

             && ! Boolean.FALSE.equals(reference.getNavigable());

         if (bidirectional && fkConstraint!=null && reverseFkColumn!=null) {

             boolean holdsFk = FkEnum.IMPORTED.equals(fkConstraint.getFkType());

             boolean manyToManyPick = 

                 Cardinality.MANY_TO_MANY.equals(fkConstraint.getCardinality())

                 && (

                         Boolean.TRUE.equals(owningSideAlreadySet)

                         || fkConstraint.getParentTable().getName().compareTo(reverseFkColumn.getParentTable().getName())>0

                    );

             if (holdsFk || manyToManyPick)

                 reference.put(Keys.OWNING_SIDE.toString(), true);

         } else { //in unidirectional relationships, navigable side is the owner

             if (Boolean.TRUE.equals(reference.getNavigable()))

                 reference.put(Keys.OWNING_SIDE.toString(), true);

         }

     }

     protected void warn(String msg) {

         log.warn(StringUtil.lastToken(this.getClass().getName(),'.')+" - "+msg+" - can't determine relationship owning side properly.");

     }

 }