package org.litesoft.generator;

import java.util.*;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.aokeyhole.objects.attributes.*;
import org.litesoft.aokeyhole.objects.properties.*;
import org.litesoft.aokeyhole.objects.support.*;
import org.litesoft.bo.*;
import org.litesoft.bo.change.*;
import org.litesoft.codegen.*;
import org.litesoft.core.simpletypes.currency.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.util.*;

public abstract class AbstractTypeFileGenerator extends SourceCodeGenerator
{
    protected interface AttributeProxy
    {
        boolean isInjected();

        String getDerivedFromAttribute();

        String getName();

        String getColumnName();

        Mutability getMutability();

        boolean isSysSetOnly();

        String getNotes();

        boolean isVirtual();

        Class getSimpleDataType();

        String[] getValidOptions();

        BoAttribute.AttributeType getBoAttributeType();

        AttributeType getAttributeType();

        boolean isRequired();

        boolean isQueryView();

        PropertyManager getPropertyManager();

        String getToManyFullyQualifiedName();

        String getToManyBackReference();

        AttributeProxy getToManyBackReferenceAttributeProxy();

        String getToOneFullyQualifiedName();

        String getToOneBackReference();

        AttributeProxy getToOneBackReferenceAttributeProxy();
    }

    protected final ErrorSinc mErrorSinc;
    protected final ObjectRef mObjectRef, mParentObjectRef;
    protected final ObjectMetaData mObjectMetaData;
    protected final String mPackage, mObjectName, mClassName;
    protected final boolean mIsParent;

    public AbstractTypeFileGenerator( String pReportingType, ErrorSinc pErrorSinc, ObjectMetaData pObjectMetaData, ObjectRef pObjectRef, String pTypeExtension, ObjectRef pParentObjectRef, boolean pIsParent )
    {
        super( pReportingType, pObjectRef.getFullFolderPath() + "/" + pObjectMetaData.getName() + pTypeExtension + ".java" );
        mErrorSinc = pErrorSinc;
        mObjectRef = pObjectRef;
        mParentObjectRef = pParentObjectRef;
        mPackage = pObjectRef.getPackage();
        mClassName = (mObjectName = (mObjectMetaData = pObjectMetaData).getName()) + pTypeExtension;
        mIsParent = pIsParent;
        setOverwrite( mClassName.endsWith( "GO" ) );
    }

    public final SourceCodeGenerator generate()
    {
        addPackage( mPackage );

        LLaddImports();

        LLaddClassDefinition();

        LLaddClassBody();

        addClassEnd();

        return this;
    }

    protected String getExtends( String pNoParentClassPrefix )
    {
        if ( mParentObjectRef == null )
        {
            return pNoParentClassPrefix;
        }
        return removePackageIfPossible( mParentObjectRef.getFullyQualifiedName() );
    }

    protected String removePackageIfPossible( String pFullyQualifiedName )
    {
        int zDotAt = pFullyQualifiedName.lastIndexOf( '.' );
        if ( (zDotAt != -1) && mPackage.equals( pFullyQualifiedName.substring( 0, zDotAt ) ) )
        {
            pFullyQualifiedName = pFullyQualifiedName.substring( zDotAt + 1 );
        }
        return pFullyQualifiedName;
    }

    protected void LLaddImports()
    {
    }

    abstract protected void LLaddClassDefinition();

    protected void LLaddClassBody()
    {
    }

    abstract protected AttributeProxy[] getAttributes();

    protected static Mutability convertToMutability( AttributeMetaData pAttribute )
    {
        AttributeType zType = pAttribute.getAttributeSet().getType();
        if ( A_ID.TYPE.equals( zType ) )
        {
            return Mutability.AddOnly;
        }
        String zChangeable = pAttribute.getPropertyManager().get_String( PMD_Changeable.NAME, "" ).trim();
        if ( PMD_Changeable.ADD_ONLY.equals( zChangeable ) )
        {
            return Mutability.AddOnly;
        }
        if ( PMD_Changeable.READ_ONLY.equals( zChangeable ) )
        {
            return Mutability.RO;
        }
        return Mutability.RW;
    }

    protected BoAttribute.AttributeType getType( AttributeMetaData pAttribute )
    {
        AttributeType zAttributeType = pAttribute.getAttributeSet().getType();
        if ( zAttributeType.getFAT().isSimple() )
        {
            Class zTypeClass = zAttributeType.getSimpleDataType();
            if ( zTypeClass == null )
            {
                mErrorSinc.addError( "CurrentlyUnsupportedAttributeType", pAttribute.toString(), mObjectMetaData.toStringForError() );
            }
            else
            {
                String zType = zTypeClass.getName();
                int zAt = zType.lastIndexOf( '.' );
                if ( zAt != -1 )
                {
                    zType = zType.substring( zAt + 1 );
                }
                try
                {
                    return BoAttribute.AttributeType.valueOf( zType );
                }
                catch ( IllegalArgumentException e )
                {
                    mErrorSinc.addError( "CurrentlyUnsupportedAttributeType", "of: " + zType, pAttribute.toString(), mObjectMetaData.toStringForError() );
                }
            }
        }
        return null;
    }

    protected Class extractSimpleDataType( AttributeMetaData pAttribute )
    {
        return pAttribute.getAttributeSet().getType().getSimpleDataType();
    }

    protected void addNotes( String pNotes )
    {
        if ( Utils.isNotNullOrEmpty( pNotes ) )
        {
            addLine( "/**" );
            String[] zLines = Utils.parseChar( Utils.normalizeNewLines( pNotes ), '\n' );
            for ( String zLine : zLines )
            {
                addLine( " " + ("* " + zLine).trim() );
            }
            addLine( " */" );
        }
    }

    protected String adjustOptionForName( String pOption )
    {
        StringBuilder rv = new StringBuilder( pOption );
        for ( int i = 0; i < rv.length(); i++ )
        {
            char c = rv.charAt( i );
            if ( (c != '_') && !Utils.isAlphaNumeric( c ) )
            {
                rv.setCharAt( i, '_' );
            }
        }
        return rv.toString();
    }

    protected AttributeMetaData getAttribute( ObjectMetaData pObjectMetaData, String pAttrName )
    {
        AttributeMetaData zAMD = null;
        while ( (pObjectMetaData != null) && (null == (zAMD = pObjectMetaData.getAttribute( pAttrName ))) )
        {
            String zParentName = Utils.noEmpty( pObjectMetaData.getParentName() );
            SystemMetaData zSystemMetaData = pObjectMetaData.getSystemMetaData();
            pObjectMetaData = ((zSystemMetaData != null) && (zParentName != null)) ? zSystemMetaData.getObject( zParentName ) : null;
        }
        return zAMD;
    }

    protected SystemMetaData getSystemMetaData( MetaDataOwner pOwner )
    {
        while ( pOwner instanceof AbstractNamedMetaData )
        {
            pOwner = ((AbstractNamedMetaData) pOwner).getOwner();
        }
        return (pOwner instanceof SystemMetaData) ? (SystemMetaData) pOwner : null;
    }

    protected void LLaddAttributes( boolean pAddBlank )
    {
        for ( AttributeProxy zAttribute : getAttributes() )
        {
            if ( pAddBlank )
            {
                addBlankLine();
            }
            pAddBlank = true;
            LLaddAttribute( zAttribute );
        }
    }

    protected void addPSFSattributeValidOptions( AttributeProxy pAttribute, String pPOorVO )
    {
        String[] zOptions = pAttribute.getValidOptions();
        if ( Utils.isNotNullOrEmpty( zOptions ) && (zOptions.length < 10) )
        {
            addBlankLine();
            for ( String zOption : zOptions )
            {
                if ( Utils.isNotNullOrEmpty( zOption ) )
                {
                    addPSFS( pPOorVO + pAttribute.getName() + "_" + adjustOptionForName( zOption ), zOption );
                }
            }
        }
    }

    protected void LLaddAttribute( AttributeProxy zAttribute )
    {
    }

    protected String createAttributeTypedCall( AttributeProxy pAttribute, String pPOorVO, String pBaseLine, String pLineTerminator )
    {
        String zName = pAttribute.getName();

        Mutability zMutability = pAttribute.getMutability();

        String zRequired = pAttribute.isRequired() ? ", true" : ", false";

        BoAttribute.AttributeType zType = pAttribute.getBoAttributeType();
        if ( zType == null )
        {
            mErrorSinc.addError(
                    pPOorVO + " CurrentlyUnsupportedAttributeType",
                    "of: " + pAttribute.getAttributeType(), pAttribute.toString(), mObjectMetaData.toStringForError() );
            zType = BoAttribute.AttributeType.String;
        }

        AttributeType zAttributeType = pAttribute.getAttributeType();
        String zEnumType = zType.toString();

        PropertyManager zPM = pAttribute.getPropertyManager();
        List<String> zProperties = new ArrayList<String>();

        String[] zOptions = pAttribute.getValidOptions();
        if ( zOptions != null )
        {
            zProperties.add( "Options.of( sValidOptions" + zName + " )" );
            zEnumType = "ValidOptions";
        }
        else if ( A_ArrayOptions.TYPE.equals( zAttributeType ) )
        {
            String zArrayRef = Utils.noEmpty( zPM.get_String( PMD_FullyQualifiedStringArrayPath.NAME, "" ) );
            if ( zArrayRef == null )
            {
                mErrorSinc.addError( "AttributeStringArrayPath", "Missing", pAttribute.toString(), mObjectMetaData.toStringForError() );
            }
            zProperties.add( "Options.of( " + zArrayRef + " )" );
            zEnumType = "ValidOptions";
        }
        else if ( A_Password.TYPE.equals( zAttributeType ) )
        {
            zEnumType = "Password";
        }
        else if ( A_Text.TYPE.equals( zAttributeType ) )
        {
            zEnumType = "Text";
        }
        String zProperty = noEmpty( zPM.getProperty( PMD_Case.NAME ) );
        if ( zProperty != null )
        {
            zProperties.add( PMD_Case.NAME + "." + zProperty );
        }
        // Will be rendered in REVERSE order
        add( zProperties, zPM, PMD_DisplayLength.NAME, "DisplayLength" );
        add( zProperties, zPM, PMD_MaxLength.NAME, "MaxLength" );
        add( zProperties, zPM, PMD_DisplayHeightInitial.NAME, "DisplayHeightInitial" );
        add( zProperties, zPM, PMD_DisplayWidthInitial.NAME, "DisplayWidthInitial" );

        pBaseLine += zRequired + ", _" + zEnumType;
        if ( !Mutability.RW.equals( zMutability ) )
        {
            pBaseLine += "." + zMutability + "()";
        }
        if ( zProperties.isEmpty() )
        {
            addLine( pBaseLine + " )" + pLineTerminator );
        }
        else
        {
            pBaseLine += ".with( ";
            int i = zProperties.size();
            if ( i == 1 )
            {
                addLine( pBaseLine + zProperties.get( --i ) + " ) )" + pLineTerminator );
            }
            else
            {
                String zPadding = Utils.spaces( pBaseLine.length() );
                addLine( pBaseLine + zProperties.get( --i ) + ", //" );
                while ( i > 1 )
                {
                    addLine( zPadding + zProperties.get( --i ) + ", //" );
                }
                addLine( zPadding + zProperties.get( --i ) + " ) )" + pLineTerminator );
            }
        }
        String zTypeExtra = "";
        if ( SimpleMoney.class.equals( zType.getType() ) )
        {
            zTypeExtra = "org.litesoft.core.simpletypes.currency.SimpleCurrency.US, ";
        }
        else if ( SimpleDate.class.equals( zType.getType() ) )
        {
            zTypeExtra = "org.litesoft.core.simpletypes.temporal.DateFormatControl.DEFAULT_DATE_FORMAT, ";
        }
        else if ( SimpleTime.class.equals( zType.getType() ) )
        {
            zTypeExtra = "org.litesoft.core.simpletypes.temporal.TimeRes.ToMIN, ";
        }
        else if ( SimpleTimestamp.class.equals( zType.getType() ) )
        {
            zTypeExtra = "org.litesoft.core.simpletypes.temporal.TimeRes.ToMSEC, ";
        }
        return zTypeExtra;
    }

    protected void add( List<String> pCollector, PropertyManager pPropertyManager, String pProperty, String pWhat )
    {
        String zProperty = noEmpty( pPropertyManager.getProperty( pProperty ) );
        if ( zProperty != null )
        {
            pCollector.add( pWhat + ".of( " + zProperty + " )" );
        }
    }

    private String noEmpty( Property pProperty )
    {
        return (pProperty != null) ? Utils.noEmpty( pProperty.getValueAsString() ) : null;
    }

    protected void addTopValidOptions( String pPOorVO )
    {
        for ( AttributeProxy zAttribute : getAttributes() )
        {
            addTopPSFSattributeValidOptions( zAttribute, pPOorVO );
        }
    }

    private void addTopPSFSattributeValidOptions( AttributeProxy pAttribute, String pPOorVO )
    {
        String[] zOptions = pAttribute.getValidOptions();
        if ( zOptions != null )
        {
            addLine( "public static final String[] sValidOptions" + pAttribute.getName() + " = //" );
            indentStart();
            indentStart();
            addLine( "{ //" );
            indentPlus( 2 );

            if ( (zOptions.length < 10) )
            {
                for ( String zOption : zOptions )
                {
                    if ( Utils.isNotNullOrEmpty( zOption ) )
                    {
                        addLine( pPOorVO + pAttribute.getName() + "_" + adjustOptionForName( zOption ) + ", //" );
                    }
                }
            }
            else
            {
                for ( String zOption : zOptions )
                {
                    if ( Utils.isNotNullOrEmpty( zOption ) )
                    {
                        addLine( quote( zOption ) + ", //" );
                    }
                }
            }

            indentMinus( 2 );
            addLine( "};" );
            indentEnd();
            indentEnd();
            addBlankLine();
        }
    }
}