package oisoft.togetherx.scripts.SQL.impl;

import java.util.Enumeration;

import COM.objectspace.jgl.HashMap;
import COM.objectspace.jgl.HashSet;

import oisoft.togetherx.scriptapi.UML.UMLPackage;
import oisoft.togetherx.scriptapi.UML.UMLClass;
import oisoft.togetherx.scriptapi.UML.UMLAssociation;

import oisoft.togetherx.scriptapi.UML.enums.UMLAssociationEnumeration;

import oisoft.togetherx.scripts.SQL.SQLModel;
import oisoft.togetherx.scripts.SQL.SQLTable;

public class SQLModelImpl implements SQLModel {
/**
  @return Enumeration of Strings -- catalog names
*/
  public Enumeration getCatalogs(){
    return new EmptyEnumeration();
  }
/**
  @return Enumeration of Strings -- schema names
*/
  public Enumeration getSchemas(){
    return new EmptyEnumeration();
  }
  public Enumeration getTables(){
    return new TableEnumeration(myPackage.getClasses(),this);
  }
  public boolean checkConsistency(){
    HashSet checked = new HashSet();
    HashSet current = new HashSet();

    for( Enumeration tables = getTables(); tables.hasMoreElements(); ){
      TableImpl currTable = (TableImpl)tables.nextElement();
      if( !checkConsistencyStep(currTable,checked,current) ){
        return false;
      }
      for(Enumeration enum = current.elements(); enum.hasMoreElements(); ){
        checked.add(enum.nextElement());
      }
      current.clear();
    }
    return true;
  }

  private boolean checkConsistencyStep(TableImpl table, HashSet checked, HashSet current){
    if( checked.get(table) != null ){
      // already checked
      return true;
    }
    if( current.get(table) != null ){
      // cycle in identifying links
      return false;
    }
    try{
      current.add(table);
      for( UMLAssociationEnumeration links = table.getUMLClass().getAssociations(); links.hasMoreElements(); ){
        UMLAssociation link = links.getNextUMLAssociation();
        // only identifying links can cause problems
        if( !link.hasProperty(getTags().linkIdentifying()) ){
          continue;
        }
        if( link.getDest() instanceof UMLClass ){
          TableImpl destTable = (TableImpl)getTable((UMLClass)link.getDest());
          if( !checkConsistencyStep(destTable,checked,current) ){
            return false;
          }
        }
      }
      // no problems found
      checked.add(table);
      return true;
    }
    finally{
      current.remove(table);
    }
  }

  public SQLModelImpl(UMLPackage pkg){
    this(pkg,new DefaultDiagramTags());
  }

  public SQLModelImpl(UMLPackage pkg, SQLDiagramTags tags){
    this(pkg,tags,new DefaultNameConstraints());
  }

  public SQLModelImpl(UMLPackage pkg, SQLDiagramTags tags, SQLNameConstraints nameConstraints){
    myPackage = pkg;
    myTags = tags;
    myNameConstraints = nameConstraints;
  }
  SQLTable getTable(UMLClass clazz){
    SQLTable result = (SQLTable)myTables.get(clazz);
    if( result == null ){
      result = new TableImpl(clazz,this);
      myTables.put(clazz,result);
      String name = result.getName();
    }
    return result;
  }

  String dereserve(String name){
    String result = name;
    while( getNameConstraints().isReservedWord(result) && result.length() > 1 ){
      System.out.println("dereserve: "+result);
      result = getNameConstraints().shorten(result,result.length()-1);
    }
    if( getNameConstraints().isReservedWord(result) ){
      result = getNameConstraints().shorten(name+"_",getNameConstraints().getMaxTableNameLength());
    }
    return result;
  }

  boolean isNameRegistered(String name){
    return myNameRegistry.get(name.toLowerCase()) != null;
  }

  void registerName(String name){
    myNameRegistry.add(name.toLowerCase());
  }

  String getUniqueName(String base, int length){
    int i = 2;
    String result = base;
    while( isNameRegistered(result) ){
      result = base+i;
      result = getNameConstraints().shorten(result,length);
      result = dereserve(result);
      ++i;
    }
    registerName(result);
    return result;
  }

  String createTableName (String className){
    String result = getNameConstraints().shorten(className,getNameConstraints().getMaxTableNameLength());
    result = dereserve(result);
    result = getUniqueName(result,getNameConstraints().getMaxTableNameLength());
    return result;
  }

  SQLDiagramTags getTags(){
    return myTags;
  }
  SQLNameConstraints getNameConstraints(){
    return myNameConstraints;
  }

  private HashMap myTables = new HashMap();
  private HashSet myNameRegistry = new HashSet();
  private UMLPackage myPackage;
  private SQLDiagramTags myTags;
  private SQLNameConstraints myNameConstraints;
}