/*
    * 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.agile.db.model;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.xml.bind.annotation.XmlAnyElement;
  import javax.xml.bind.annotation.XmlAttribute;
  import javax.xml.bind.annotation.XmlRootElement;
  import javax.xml.bind.annotation.XmlTransient;
  
  import org.javagen.agile.core.annotation.DefaultValue;
  import org.javagen.agile.core.model.AbstractModel;
  import org.javagen.agile.core.model.Model;
  
  @XmlRootElement
  public class Table extends AbstractModel {
  	
      public static final String DEFAULT_MODEL_TYPE = "TABLE";
  
      transient protected List<PkColumn> primaryKeys;
      protected List<FkConstraint> fkConstraints;
      //protected List<UniqueConstraint> uniqueConstraints;
  	protected Boolean linkTable;
      //private static List<FkColumn> EMPTY_FK_COLUMNS = new ArrayList<FkColumn>();
  
  	public Table() {
          super();
          this.setModelType(DEFAULT_MODEL_TYPE);
  	}
  	
      public Table(Database parentDatabase) {
          this();
          this.setParentDatabase(parentDatabase);
      }
      
      public Table(String name) {
          this();
          this.setName(name);
      }
      
  //	public Model getParentModel() { return this.getParentDatabase(); }
  //	
  //	public void setParentModel(Model parentDatabase) {
  //		this.setParentDatabase( (Database)parentDatabase );
  //	}
  //
      @XmlTransient
  	public Database getParentDatabase() {
  		return (Database)getParentModel();
  	}
  
  	public void setParentDatabase(Database parentDatabase) {
  		this.setParentModel(parentDatabase);
  	}
  
      @Override
      public void copyTo(Model targetModel) {
          Table target = (Table)targetModel;
          super.copyTo(target);
          if (this.isLinkTable()!=null)
              target.setLinkTable(this.isLinkTable());
      }
  
      public List<Model> allOwnedModels() {
          int size = getChildModels().size() + this.getFkColumns().size();
          List<Model> all = new ArrayList<Model>(size);
          all.addAll(getChildModels());
          all.addAll(getFkColumns());
          return all;
      }
      
  	////////////////////////////////////////////////////////////////////////////
  	// Column handling:
  	////////////////////////////////////////////////////////////////////////////
  
  	public Column createColumn() {
  		return new Column(this);
  	}
  	
  	public Column addColumn(String name, DbType dbType, Object defaultValue, Boolean notNull, Boolean unique, Integer columnSize, Integer scale) {
  		Column column = createColumn();
  		column.setName(name);
  		column.setDbType(dbType);
  		column.setDefaultValue(defaultValue);
 		column.setNotNull(notNull);
 		column.setColumnSize(columnSize);
 		column.setScale(scale);
 		column.setUnique(unique);
 		this.addColumn(column);
 		return column;
 	}
 	
 	public PkColumn createPkColumn() {
 		return new PkColumn(this);
 	}
 	
 	public PkColumn addPkColumn(String name, DbType dbType, Object defaultValue, Boolean autoIncrement, Integer columnSize, Integer scale) {
 		PkColumn column = createPkColumn();
 		column.setName(name);
 		column.setDbType(dbType);
 		column.setDefaultValue(defaultValue);
 		column.setNotNull(Boolean.TRUE);
 		column.setColumnSize(columnSize);
 		column.setScale(scale);
 		column.setUnique(Boolean.TRUE);
 		column.setAutoIncrement(autoIncrement);
 		this.addColumn(column);
 		return column;
 	}
 	
 	public Column lookupColumn(String name) {
 		if (this.getColumns()==null)
 			return null;
 		for(Column column : this.getColumns()) {
 			if (column.getName().equalsIgnoreCase(name))
 				return column;
 		}
 		return null;
 	}
 	
     @XmlTransient
 	public List<Column> getColumns() {
         List<Column> list = new ArrayList<Column>(getChildModels().size());
         for(Model child : getChildModels())
             list.add((Column)child);
         return list;
 	}
 
 //	public void setColumns(List<Column> columns) {
 //		this.setChildModels(columns);
 //	}
 //
 	public void addColumn(Column column) {
         addChildModel(column);
 	}
 
 	////////////////////////////////////////////////////////////////////////////
 	// FkColumn handling:
 	////////////////////////////////////////////////////////////////////////////
 
 	public FkConstraint createFkColumn() {
 		return new FkConstraint(this);
 	}
 	
     public void addFkColumn(FkConstraint fkConstraint) {
         if (fkConstraints==null) {
             fkConstraints = new ArrayList<FkConstraint>();
         }
         fkConstraints.add(fkConstraint);
         fkConstraint.setParentTable(this);
     }
 
 	public FkConstraint lookupFkColumn(String name) {
 		if (this.getFkColumns()==null)
 			return null;
 		for(FkConstraint fkConstraint : this.getFkColumns()) {
 			if (fkConstraint.getName().equalsIgnoreCase(name))
 				return fkConstraint;
 		}
 		return null;
 	}
 	
     @XmlAnyElement
 	public List<FkConstraint> getFkColumns() {
 		if (fkConstraints==null)
             fkConstraints = new ArrayList<FkConstraint>();
         return fkConstraints;
 	}
 
 	public void setFkColumns(List<FkConstraint> fkConstraints) {
 		this.fkConstraints = fkConstraints;
         if (this.fkConstraints!=null) {
             for(FkConstraint child : this.fkConstraints)
                 child.setParentModel(this);
         }
 	}
 
     /***
      * Default value if not set is false.
      */
     @XmlAttribute
     @DefaultValue("false")
 	public Boolean isLinkTable() {
 		return linkTable;
 	}
 
 	public void setLinkTable(Boolean linkTable) {
 		this.linkTable = linkTable;
 	}
 
 	public boolean hasCompositeKey() {
 		List<PkColumn> pks = getPrimaryKeys();
 		return (pks!=null && pks.size()>1);
 	}
 	
     @XmlTransient
 	public List<PkColumn> getPrimaryKeys() {
 		if (primaryKeys==null && getColumns()!=null) {
 			primaryKeys = new ArrayList<PkColumn>();
 			for(Column column : this.getColumns()) {
 				if (column instanceof PkColumn)
 					primaryKeys.add( (PkColumn)column );
 			}
 		}
 		return primaryKeys;
 	}
 
     @Override
     public int hashCode() {
         final int PRIME = 31;
         int result = 1;
         result = PRIME * result + ((fkConstraints == null) ? 0 : fkConstraints.hashCode());
         result = PRIME * result + ((linkTable == null) ? 0 : linkTable.hashCode());
         result = PRIME * result + ((primaryKeys == null) ? 0 : primaryKeys.hashCode());
         return result;
     }
 
     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (!super.equals(obj))
             return false;
         if (getClass() != obj.getClass())
             return false;
         final Table other = (Table) obj;
         if (fkConstraints == null) {
             if (other.fkConstraints != null)
                 return false;
         } else if (!fkConstraints.equals(other.fkConstraints))
             return false;
         if (linkTable == null) {
             if (other.linkTable != null)
                 return false;
         } else if (!linkTable.equals(other.linkTable))
             return false;
         if (primaryKeys == null) {
             if (other.primaryKeys != null)
                 return false;
         } else if (!primaryKeys.equals(other.primaryKeys))
             return false;
         return true;
     }
 
     
 //    Oct 06 - problems with XML serialization
 //   
 //    @XmlTransient
 //    public List<UniqueConstraint> getUniqueConstraints() {
 //        return uniqueConstraints;
 //    }
 //
 //    public void setUniqueConstraints(List<UniqueConstraint> uniqueConstraints) {
 //        this.uniqueConstraints = uniqueConstraints;
 //    }
 //
 //    public void addUniqueConstraint(UniqueConstraint uniqueConstraint) {
 //        if (uniqueConstraints==null)
 //            uniqueConstraints = new ArrayList<UniqueConstraint>();
 //        uniqueConstraints.add(uniqueConstraint);
 //    }
 //
 //    public UniqueConstraint lookupUniqueConstraint(String constraintName) {
 //        if (uniqueConstraints!=null)
 //            for(UniqueConstraint uniqueConstraint : uniqueConstraints)
 //                if (uniqueConstraint.getName().equalsIgnoreCase(constraintName))
 //                    return uniqueConstraint;
 //        return null;
 //    }
 
 }