package org.apache.ojb.broker.ant;

 /* Copyright 2004-2005 The Apache Software Foundation

 *

 * 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.

 */

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.TreeMap;

 import org.apache.commons.beanutils.DynaBean;

 import org.apache.ddlutils.model.Column;

 import org.apache.ddlutils.model.Database;

 import org.apache.ddlutils.model.Table;

 import org.apache.ojb.broker.metadata.ClassDescriptor;

 import org.apache.ojb.broker.metadata.CollectionDescriptor;

 import org.apache.ojb.broker.metadata.DescriptorRepository;

 import org.apache.ojb.broker.metadata.FieldDescriptor;

 /**

  * Provides a model derived from {@link org.apache.ojb.broker.metadata.DescriptorRepository} that

  * is preprocessed for data handling (inserting data, generating data dtd).

  * 

  * @author Thomas Dudziak

  */

 public class PreparedModel

 {

     /** The database model. */

     private Database _schema;

     /** Maps dtd elements to tables */

     private TreeMap _elementToTable                 = new TreeMap();

     /** Maps dtd elements to lists of class descriptors (which all map to the same table) */

     private HashMap _elementToClassDescriptors      = new HashMap();

     /** Maps dtd elements to colum maps which in turn map attribute names to columns */

     private HashMap _elementToColumnMap             = new HashMap();

     /** Maps dtd elements to maps that specify which attributes are required */

     private HashMap _elementToRequiredAttributesMap = new HashMap();

     public PreparedModel(DescriptorRepository model, Database schema)

     {

         _schema = schema;

         prepareModel(model);

     }

     public Iterator getElementNames()

     {

         return _elementToTable.keySet().iterator();

     }

     public Iterator getAttributeNames(String elementName)

     {

         Map columns = getColumnsFor(elementName);

         return columns == null ? null : columns.keySet().iterator();

     }

     public Map getRequiredAttributes(String elementName)

     {

         return (Map)_elementToRequiredAttributesMap.get(elementName);

     }

     public boolean isRequired(String elementName, String attributeName)

     {

         Map requiredAttributes = getRequiredAttributes(elementName);

         if (requiredAttributes == null)

         {

             return false;

         }

         else

         {

             Boolean status = (Boolean)requiredAttributes.get(attributeName);

             return status == null ? false : status.booleanValue();

         }

     }

     public Table getTableFor(String elementName)

     {

         return (Table)_elementToTable.get(elementName);

     }

     /**

      * Creates a dyna bean for the table associated to the given element.

      * 

      * @param elementName The element name

      * @return The dyna bean

      */

     public DynaBean createBeanFor(String elementName)

     {

         return _schema.createDynaBeanFor(getTableFor(elementName));

     }

     public List getClassDescriptorsMappingTo(String elementName)

     {

         return (List)_elementToClassDescriptors.get(elementName);

     }

     public Map getColumnsFor(String elementName)

     {

         return (Map)_elementToColumnMap.get(elementName);

     }

     public Column getColumnFor(String elementName, String attrName)

     {

         Map columns = getColumnsFor(elementName);

         if (columns == null)

         {

             return null;

         }

         else

         {

             return (Column)columns.get(attrName);

         }

     }

     /**

      * Prepares a representation of the model that is easier accessible for our purposes.

      * 

      * @param model  The original model

      * @return The model representation

      */

     private void prepareModel(DescriptorRepository model)

     {

         TreeMap result = new TreeMap();

         for (Iterator it = model.getDescriptorTable().values().iterator(); it.hasNext();)

         {

             ClassDescriptor classDesc = (ClassDescriptor)it.next();

             if (classDesc.getFullTableName() == null)

             {

                 // not mapped to a database table

                 continue;

             }

             String elementName        = getElementName(classDesc);

             Table  mappedTable        = getTableFor(elementName);

             Map    columnsMap         = getColumnsFor(elementName);

             Map    requiredAttributes = getRequiredAttributes(elementName);

             List   classDescs         = getClassDescriptorsMappingTo(elementName);

             if (mappedTable == null)

             {

                 mappedTable = _schema.findTable(classDesc.getFullTableName());

                 if (mappedTable == null)

                 {

                     continue;

                 }

                 columnsMap         = new TreeMap();

                 requiredAttributes = new HashMap();

                 classDescs         = new ArrayList();

                 _elementToTable.put(elementName, mappedTable);

                 _elementToClassDescriptors.put(elementName, classDescs);

                 _elementToColumnMap.put(elementName, columnsMap);

                 _elementToRequiredAttributesMap.put(elementName, requiredAttributes);

             }

             classDescs.add(classDesc);

             extractAttributes(classDesc, mappedTable, columnsMap, requiredAttributes);

         }

         extractIndirectionTables(model, _schema);

     }

     private void extractAttributes(ClassDescriptor classDesc, Table mappedTable, Map columnsMap, Map requiredColumnsMap)

     {

         FieldDescriptor[] fieldDescs = classDesc.getFieldDescriptions();

         if (fieldDescs != null)

         {

             for (int idx = 0; idx < fieldDescs.length; idx++)

             {

                 Column column = mappedTable.findColumn(fieldDescs[idx].getColumnName());

                 if (column != null)

                 {

                     // we'll check whether another field (of not necessarily the same name)

                     // already maps to this column; if this is the case, we're ignoring

                     // this field

                     boolean alreadyMapped = false;

                     for (Iterator mappedColumnsIt = columnsMap.values().iterator(); mappedColumnsIt.hasNext();)

                     {

                         if (column.equals(mappedColumnsIt.next()))

                         {

                             alreadyMapped = true;

                             break;

                         }

                     }

                     if (!alreadyMapped)

                     {

                         String shortAttrName = getShortAttributeName(fieldDescs[idx].getAttributeName());

                         columnsMap.put(shortAttrName, column);

                         requiredColumnsMap.put(shortAttrName,

                                                fieldDescs[idx].isPrimaryKey() ? Boolean.TRUE : Boolean.FALSE);

                     }

                 }

             }

         }

     }

     /**

      * Extracts indirection tables from the given class descriptor, and adds elements

      * for them. In contrast to normal elements, for indirection tables the element name

      * matches the table name, and the attribute names match the column names.

      * 

      * @param model    The model

      * @param elements The elements

      */

     private void extractIndirectionTables(DescriptorRepository model, Database schema)

     {

         HashMap indirectionTables = new HashMap();

         // first we gather all participants for each m:n relationship

         for (Iterator classDescIt = model.getDescriptorTable().values().iterator(); classDescIt.hasNext();)

         {

             ClassDescriptor classDesc = (ClassDescriptor)classDescIt.next();

             for (Iterator collDescIt = classDesc.getCollectionDescriptors().iterator(); collDescIt.hasNext();)

             {

                 CollectionDescriptor collDesc   = (CollectionDescriptor)collDescIt.next();

                 String               indirTable = collDesc.getIndirectionTable();

                 if ((indirTable != null) && (indirTable.length() > 0))

                 {

                     Set columns = (Set)indirectionTables.get(indirTable);

                     if (columns == null)

                     {

                         columns = new HashSet();

                         indirectionTables.put(indirTable, columns);

                     }

                     columns.addAll(Arrays.asList(collDesc.getFksToThisClass()));

                     columns.addAll(Arrays.asList(collDesc.getFksToItemClass()));

                 }

             }

         }

         if (indirectionTables.isEmpty())

         {

             // nothing to do

             return;

         }

         for (Iterator it = indirectionTables.keySet().iterator(); it.hasNext();)

         {

             String tableName   = (String)it.next();

             Set    columns     = (Set)indirectionTables.get(tableName);

             String elementName = tableName;

             for (Iterator classDescIt = model.getDescriptorTable().values().iterator(); classDescIt.hasNext();)

             {

                 ClassDescriptor classDesc = (ClassDescriptor)classDescIt.next();

                 if (tableName.equals(classDesc.getFullTableName()))

                 {

                     elementName = getElementName(classDesc);

                     FieldDescriptor[] fieldDescs = classDesc.getFieldDescriptions();

                     if (fieldDescs != null)

                     {

                         for (int idx = 0; idx < fieldDescs.length; idx++)

                         {

                             columns.remove(fieldDescs[idx].getColumnName());

                         }

                     }

                 }

             }

             Table mappedTable        = getTableFor(elementName);

             Map   columnsMap         = getColumnsFor(elementName);

             Map   requiredAttributes = getRequiredAttributes(elementName);

             if (mappedTable == null)

             {

                 mappedTable = schema.findTable(elementName);

                 if (mappedTable == null)

                 {

                     continue;

                 }

                 columnsMap         = new TreeMap();

                 requiredAttributes = new HashMap();

                 _elementToTable.put(elementName, mappedTable);

                 _elementToColumnMap.put(elementName, columnsMap);

                 _elementToRequiredAttributesMap.put(elementName, requiredAttributes);

             }

             for (Iterator columnIt = columns.iterator(); columnIt.hasNext();)

             {

                 String columnName = (String)columnIt.next();

                 Column column     = mappedTable.findColumn(columnName);

                 if (column != null)

                 {

                     columnsMap.put(columnName, column);

                     requiredAttributes.put(columnName, Boolean.TRUE);

                 }

             }

         }

     }

     /**

      * Returns the element name for the class descriptor which is the adjusted short (unqualified) class

      * name. Also takes care that the element name does not clash with another class of the same short

      * name that maps to a different table though.

      * 

      * @param classDesc The class descriptor

      * @return The element name

      */

     private String getElementName(ClassDescriptor classDesc)

     {

         String elementName = classDesc.getClassNameOfObject().replace('$', '_');

         elementName = elementName.substring(elementName.lastIndexOf('.') + 1);

         Table table  = getTableFor(elementName);

         int   suffix = 0;

         while ((table != null) && !table.getName().equals(classDesc.getFullTableName()))

         {

             ++suffix;

             table = getTableFor(elementName + "-" + suffix);

         }

         if (suffix > 0)

         {

             elementName += "-" + suffix;

         }

         return elementName;

     }

     /**

      * Adjusts the local attribute name (the part after the last '::' for nested fields).

      * 

      * @param attrName The original attribute name

      * @return The local attribute name

      */

     private String getShortAttributeName(String attrName)

     {

         return attrName.substring(attrName.lastIndexOf(':') + 1);

     }

 }