// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.generator;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.codegen.*;

public class GeneratePONamesGO extends AbstractPOFileGenerator
{
    public GeneratePONamesGO( ErrorSinc pErrorSinc, ObjectMetaData pObjectMetaData, ObjectRef pObjectRef, ObjectRef pParentObjectRef, boolean pIsParent )
    {
        super( pErrorSinc, pObjectMetaData, pObjectRef, "NamesGO", pParentObjectRef, pIsParent );
    }

    @Override
    protected void LLaddImports()
    {
        addImports( //
                    "org.litesoft.orsup.nonpublic.*", //
                    null );
    }

    @Override
    protected void LLaddClassDefinition()
    {
        makeClassAbstract();
        addClassDefinition( mClassName, getExtends( "AbstractPO" ) + "Names" );
    }

    @Override
    protected void LLaddClassBody()
    {
        if ( mIsParent )
        {
            constructorParent();
        }
        else
        {
            addPSFS( "OBJECT_NAME", mObjectName );
            addBlankLine();
            addPSFS( "DATASTORE_NAME", mPackage + "." + mObjectName );
            addBlankLine();
            constructorRegular();
        }

        LLaddAttributes( false );

        if ( !mIsParent )
        {
            addCollectionOf();
            addFactory();
            addBlankLine();
            addLine( "public static final " + mObjectName + "Names INSTANCE = new " + mObjectName + "Names( null, \"\" );" );
        }
    }

    private void constructorParent()
    {
        addConstructorProtected( mClassName, "AbstractPONames pBuiltBy", "String pObjectName", "String pDatastoreName", "String pParentPath" );
        addLine( "super( pBuiltBy, pObjectName, pDatastoreName, pParentPath );" );
        addMethodEnd();
    }

    private void constructorRegular()
    {
        addConstructorProtected( mClassName, "AbstractPONames pBuiltBy", "String pParentPath" );
        addLine( "super( pBuiltBy, OBJECT_NAME, DATASTORE_NAME, pParentPath );" );
        addMethodEnd();
    }

    @Override
    protected void LLaddAttribute( AttributeProxy pAttribute )
    {
        String zName = pAttribute.getName();
        add_aRef( zName, pAttribute.getAttributeSetType().toString() );
        String zToMany = pAttribute.getToManyFullyQualifiedName();
        if ( (zToMany != null) && pAttribute.isToManyInstantiable() )
        {
            add_rRef( zName, zToMany );
            add_cRef( zName, zToMany );
        }
        String zToOne = pAttribute.getToOneFullyQualifiedName();
        if ( (zToOne != null) && pAttribute.isToOneInstantiable() )
        {
            add_rRef( zName, zToOne );
        }
        addPSFSattributeValidOptions( pAttribute, "po" );
    }

    private void add_aRef( String pName, String pWhatType )
    {
        addNotes( pWhatType );
        addLine( "public final String a" + pName + " = mParentPath + " + quote( pName ) + ";" );
    }

    private void add_rRef( String pOurAttributeName, String pToOneFullyQualifiedName )
    {
        addBlankLine();

        String zThem = removePackageIfPossible( pToOneFullyQualifiedName ) + "Names";

        addMethodPublic( zThem, "r" + pOurAttributeName );
        addLine( "return (" + zThem + ") toOne( this, a" + pOurAttributeName + ", " + zThem + ".Factory.INSTANCE );" );
        addBlockEnd();
    }

    private void add_cRef( String pOurAttributeName, String pToManyFullyQualifiedName )
    {
        addBlankLine();

        String zThem = removePackageIfPossible( pToManyFullyQualifiedName ) + "Names";

        addMethodPublic( zThem, "c" + pOurAttributeName );
        addLine( "return (" + zThem + ") toMany( this, a" + pOurAttributeName + ", " + zThem + ".Factory.INSTANCE );" );
        addBlockEnd();
    }

    private void addCollectionOf()
    {
        addBlankLine();
        makeClassStatic();
        addClassDefinition( "CollectionOf", mObjectName + "Names", "CollectionOfPONamesAccessor" );
        addLine( "private String mCollectionPath;" );
        addBlankLine();
        addConstructorPublic( "CollectionOf", "String pCollectionPath" );
        addLine( "super( null, \"\" );" );
        addBlankLine();
        addLine( "mCollectionPath = pCollectionPath;" );
        addMethodEnd();
        addLine( "@Override" );
        addMethodPublic( "String", "getCollectionPath" );
        addLine( "return mCollectionPath;" );
        addMethodEnd();
        addLine( "@Override" );
        addMethodPublic( "String", "toString" );
        addLine( "return \"c\" + super.toString();" );
        addBlockEnd();
        addClassEnd();
    }

    private void addFactory()
    {
        addBlankLine();
        makeClassStatic();
        addClassDefinition( "Factory", null, "IFactory" );
        addLine( "public static final IFactory INSTANCE = new Factory();" );
        addBlankLine();
        addLine( "@Override" );
        addMethodPublic( "AbstractPONames", "createToOne", "AbstractPONames pBuiltBy", "String pParentPath" );
        addLine( "return new " + mObjectName + "Names( pBuiltBy, pParentPath );" );
        addMethodEnd();
        addLine( "@Override" );
        addMethodPublic( "AbstractPONames", "createToMany", "String pCollectionPath" );
        addLine( "return new " + mObjectName + "Names.CollectionOf( pCollectionPath );" );
        addBlockEnd();
        addClassEnd();
    }
}