package test.sdo21.tests.TestData;

import java.util.ArrayList;
import java.util.List;

import commonj.sdo.DataObject;
import commonj.sdo.Type;
import commonj.sdo.helper.HelperContext;
import commonj.sdo.helper.TypeHelper;

public class StandardDynamicFactory extends StandardFactory {

  public void defineMetaData(HelperContext hc) {
    TypeHelper types = hc.getTypeHelper();
      
    Type t = types.getType(TEST_NAMESPACE, "Abstract");
    if (t != null) {
        // the test types have already been defined in this HelperContext (this will happen when the
        // implementation being tested does not support multiple contexts, which is not a 2.1 requirement).
        return;
    }

    Type stringType = types.getType("commonj.sdo", "String");
    Type intType = types.getType("commonj.sdo", "Int");
    Type booleanType = types.getType("commonj.sdo", "Boolean");
    Type byteType = types.getType("commonj.sdo", "Byte");
    Type decimalType = types.getType("commonj.sdo", "Decimal");
    Type floatType = types.getType("commonj.sdo", "Float");
    Type doubleType = types.getType("commonj.sdo", "Double");
    Type dateType = types.getType("commonj.sdo", "Date");
    Type shortType = types.getType("commonj.sdo", "Short");
    Type longType = types.getType("commonj.sdo", "Long");
    Type bytesType = types.getType("commonj.sdo", "Bytes");
    Type integerType = types.getType("commonj.sdo", "Integer");
    Type charType = types.getType("commonj.sdo", "Character");

    DataObject abstractTypeDO = hc.getDataFactory().create("commonj.sdo", "Type");
    abstractTypeDO.set("uri", TEST_NAMESPACE);
    abstractTypeDO.set("name", "Abstract");
    abstractTypeDO.setBoolean("abstract", true);

    DataObject firstProperty = abstractTypeDO.createDataObject("property");
    firstProperty.set("name", "firstName");
    firstProperty.set("type", stringType);

    DataObject lastProperty = abstractTypeDO.createDataObject("property");
    lastProperty.set("name", "lastName");
    lastProperty.set("type", stringType);

    Type abstractType = types.define(abstractTypeDO);

    DataObject extendedTypeDO = hc.getDataFactory().create("commonj.sdo", "Type");
    extendedTypeDO.set("uri", TEST_NAMESPACE);
    extendedTypeDO.set("name", EXT_TYPE);
    
    List baseTypes = new ArrayList();
    baseTypes.add(abstractType);
    extendedTypeDO.setList("baseType", baseTypes);
    
    DataObject middleName = extendedTypeDO.createDataObject("property");
    middleName.set("name", "middleName");
    middleName.set("type", stringType);
    
    DataObject nickName = extendedTypeDO.createDataObject("property");
    nickName.set("name", "nickName");
    nickName.set("type", stringType);
    
    Type extendedType = types.define(extendedTypeDO);
    
    DataObject sequenceTypeDO = hc.getDataFactory().create("commonj.sdo", "Type");
    sequenceTypeDO.set("uri", TEST_NAMESPACE);
    sequenceTypeDO.set("name", SEQ_TYPE);
    sequenceTypeDO.setBoolean("sequenced", true);
    
    // TODO: Uncomment the following when SDOUtil.addAliasName is
    // implemented
    /*
     * aliases.clear(); aliases.add("Seq2"); sequenceTypeDO.set("aliasName",
     * aliases);
     */

    DataObject Letters = sequenceTypeDO.createDataObject("property");
    Letters.set("name", "Letters");
    Letters.set("type", stringType);
    Letters.setBoolean("many", true);

    DataObject Numbers = sequenceTypeDO.createDataObject("property");
    Numbers.set("name", "Numbers");
    Numbers.set("type", intType);
    Numbers.setBoolean("many", true);
    
    DataObject containManySeq = sequenceTypeDO.createDataObject("property");
    containManySeq.set("name", "containMany");
    containManySeq.set("type", sequenceTypeDO);
    containManySeq.setBoolean("many", true);
    containManySeq.setBoolean("containment", true);
    
    DataObject containSeq = sequenceTypeDO.createDataObject("property");
    containSeq.set("name", "contain");
    containSeq.set("type", sequenceTypeDO);
    containSeq.setBoolean("containment", true);

    Type sequenceType = types.define(sequenceTypeDO);

    DataObject openTypeDO = hc.getDataFactory().create("commonj.sdo", "Type");
    openTypeDO.set("uri", TEST_NAMESPACE);
    openTypeDO.set("name", "Open");
    openTypeDO.setBoolean("open", true);
    
    DataObject definedElem = openTypeDO.createDataObject("property");
    definedElem.set("name", "defined");
    definedElem.set("type", stringType);
    
    Type openType = types.define(openTypeDO);
    
    DataObject testType = hc.getDataFactory().create("commonj.sdo", "Type");
    testType.set("uri", TEST_NAMESPACE);
    testType.set("name", API_TYPE);

    DataObject stringProperty = testType.createDataObject("property");
    stringProperty.set("name", "stringVal");
    stringProperty.set("type", stringType);

    DataObject booleanProperty = testType.createDataObject("property");
    booleanProperty.set("name", "booleanVal");
    booleanProperty.set("type", booleanType);

    DataObject boolean2Property = testType.createDataObject("property");
    boolean2Property.set("name", "booleanVal2");
    boolean2Property.set("type", booleanType);

    DataObject byteProperty = testType.createDataObject("property");
    byteProperty.set("name", "byteVal");
    byteProperty.set("type", byteType);

    DataObject string2Property = testType.createDataObject("property");
    string2Property.set("name", "stringVal2");
    string2Property.set("type", stringType);

    DataObject decimalProperty = testType.createDataObject("property");
    decimalProperty.set("name", "decimalVal");
    decimalProperty.set("type", decimalType);

    DataObject decimal2Property = testType.createDataObject("property");
    decimal2Property.set("name", "decimalVal2");
    decimal2Property.set("type", decimalType);

    // TODO: Uncomment the following when SDOUtil.addAliasName is
    // implemented
    /*
     * aliases.clear(); aliases.add("Dec2");
     * decimal2Property.set("aliasName", aliases);
     */
    DataObject intProperty = testType.createDataObject("property");
    intProperty.set("name", "intVal");
    intProperty.set("type", intType);

    DataObject floatProperty = testType.createDataObject("property");
    floatProperty.set("name", "floatVal");
    floatProperty.set("type", floatType);

    DataObject doubleProperty = testType.createDataObject("property");
    doubleProperty.set("name", "doubleVal");
    doubleProperty.set("type", doubleType);

    DataObject dateProperty = testType.createDataObject("property");
    dateProperty.set("name", "dateVal");
    dateProperty.set("type", dateType);

    DataObject shortProperty = testType.createDataObject("property");
    shortProperty.set("name", "shortVal");
    shortProperty.set("type", shortType);

    DataObject longProperty = testType.createDataObject("property");
    longProperty.set("name", "longVal");
    longProperty.set("type", longType);

    DataObject containManyProperty = testType.createDataObject("property");
    containManyProperty.set("name", "containMany");
    containManyProperty.setBoolean("many", true);
    containManyProperty.setBoolean("containment", true);
    containManyProperty.set("type", testType);

    DataObject bytesProperty = testType.createDataObject("property");
    bytesProperty.set("name", "bytesVal");
    bytesProperty.set("type", bytesType);

    DataObject integerProperty = testType.createDataObject("property");
    integerProperty.set("name", "integerVal");
    integerProperty.set("type", integerType);

    DataObject charProperty = testType.createDataObject("property");
    charProperty.set("name", "charVal");
    charProperty.set("type", charType);

    DataObject readOnlyProperty = testType.createDataObject("property");
    readOnlyProperty.set("name", "readOnlyVal");
    readOnlyProperty.set("type", stringType);
    readOnlyProperty.setBoolean("readOnly", true);
   
    DataObject sequenceProperty = testType.createDataObject("property");
    sequenceProperty.set("name", "sequencedElem");
    sequenceProperty.set("type", sequenceType);
    sequenceProperty.setBoolean("containment", true);

    DataObject extendProperty = testType.createDataObject("property");
    extendProperty.set("name", "extendedElem");
    extendProperty.set("type", extendedType);
    extendProperty.setBoolean("containment", true);
    
    DataObject openProperty = testType.createDataObject("property");
    openProperty.set("name", "openElem");
    openProperty.set("type", openType);
    openProperty.setBoolean("containment", true);
    
    DataObject containProperty = testType.createDataObject("property");
    containProperty.set("name", "contain");
    containProperty.setBoolean("containment", true);
    containProperty.set("type", testType); 
    
    types.define(testType);
    
  }
  

}