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

import java.util.*;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.aokeyhole.objects.AttributeMetaData;
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.attributes.*;
import org.litesoft.codegen.*;
import org.litesoft.core.simpletypes.currency.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.core.typeutils.Objects;

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

        String getDerivedFromAttribute();

        String getColumnName();

        Mutability getMutability();

        boolean isSysSetOnly();

        Class getSimpleDataType();

        BoAttribute.AttributeType getBoAttributeType();

        boolean isRequired();

        boolean isQueryView();

        String getToManyFullyQualifiedName();

        boolean isToManyInstantiable();

        String getToManyBackReference();

        AttributeProxy getToManyBackReferenceAttributeProxy();

        String getToOneFullyQualifiedName();

        boolean isToOneInstantiable();

        String getToOneBackReference();

        @SuppressWarnings({"UnusedDeclaration"})
        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( MinimalAttributeMetaData pAttribute )
    {
        AttributeType zAttributeType = pAttribute.getAttributeSetType();
        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 void addNotes( String pNotes )
    {
        if ( Strings.isNotNullOrEmpty( pNotes ) )
        {
            addLine( "/**" );
            String[] zLines = Strings.parseChar( Strings.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 != '_') && !Characters.isAlphaNumeric( c ) )
            {
                rv.setCharAt( i, '_' );
            }
        }
        return rv.toString();
    }

    private static Map<ObjectMetaData, List<AttributeProxy>> sInjectedAttributes = new HashMap<ObjectMetaData, List<AttributeProxy>>();

    protected synchronized List<AttributeProxy> getInjectedAttributes( ObjectMetaData pObjectMetaData )
    {
        List<AttributeProxy> zInjectedAttributes = sInjectedAttributes.get( pObjectMetaData );
        if ( zInjectedAttributes == null )
        {
            sInjectedAttributes.put( pObjectMetaData, zInjectedAttributes = createInjectedAttributes( pObjectMetaData ) );
        }
        return zInjectedAttributes;
    }

    protected List<AttributeProxy> createInjectedAttributes( ObjectMetaData pObjectMetaData )
    {
        String zTimeTracked = pObjectMetaData.getPropertyManager().get_String( PMD_TimeTracked.NAME, PMD_TimeTracked.NONE );
        if ( PMD_TimeTracked.NONE.equals( zTimeTracked ) )
        {
            return Collections.emptyList();
        }
        ArrayList<AttributeProxy> zInjected = new ArrayList<AttributeProxy>();
        if ( PMD_TimeTracked.CREATED.equals( zTimeTracked ) || PMD_TimeTracked.BOTH.equals( zTimeTracked ) )
        {
            zInjected.add( IAP_CREATED );
        }
        if ( PMD_TimeTracked.LAST_MOD.equals( zTimeTracked ) || PMD_TimeTracked.BOTH.equals( zTimeTracked ) )
        {
            zInjected.add( IAP_LAST_MOD );
        }
        return zInjected;
    }

    protected MinimalAttributeMetaData getRegularOrInjectedAttribute( ObjectMetaData pObjectMetaData, String pAttrName )
    {
        AttributeMetaData zAMD = pObjectMetaData.getAttribute( pAttrName );
        if ( zAMD != null )
        {
            return zAMD;
        }
        List<AttributeProxy> zInjectedAttributes = getInjectedAttributes( pObjectMetaData );
        for ( AttributeProxy zAttribute : zInjectedAttributes )
        {
            if ( zAttribute.getName().equals( pAttrName ) )
            {
                return zAttribute;
            }
        }
        return null;
    }

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

    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 ( Objects.isNotNullOrEmpty(zOptions) && (zOptions.length < 10) )
        {
            addBlankLine();
            for ( String zOption : zOptions )
            {
                if ( Strings.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.getAttributeSetType(), pAttribute.toString(), mObjectMetaData.toStringForError() );
            zType = BoAttribute.AttributeType.String;
        }

        AttributeType zAttributeType = pAttribute.getAttributeSetType();
        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 = (zAttributeType instanceof HasOpenOption) ? "OpenValidOptions" : "ValidOptions";
        }
        else if ( zAttributeType instanceof AbstractArrayOptionsAttributeTypeSimple )
        {
            String zArrayRef = Strings.noEmpty( zPM.get_String( PMD_FullyQualifiedStringArrayPath.NAME, "" ) );
            if ( zArrayRef == null )
            {
                mErrorSinc.addError( "AttributeStringArrayPath", "Missing", pAttribute.toString(), mObjectMetaData.toStringForError() );
            }
            zProperties.add( "Options.of( " + zArrayRef + " )" );
            zEnumType = (zAttributeType instanceof HasOpenOption) ? "OpenValidOptions" : "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 = Strings.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 ( Money.class.equals( zType.getType() ) )
        {
            zTypeExtra = "org.litesoft.core.simpletypes.currency.Currency.US, ";
        }
        else if ( CalendarYMD.class.equals( zType.getType() ) )
        {
            zTypeExtra = "org.litesoft.core.simpletypes.temporal.DateFormatControl.DEFAULT_YMD_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) ? Strings.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 ( Strings.isNotNullOrEmpty( zOption ) )
                    {
                        addLine( pPOorVO + pAttribute.getName() + "_" + adjustOptionForName( zOption ) + ", //" );
                    }
                }
            }
            else
            {
                for ( String zOption : zOptions )
                {
                    if ( Strings.isNotNullOrEmpty( zOption ) )
                    {
                        addLine( quote( zOption ) + ", //" );
                    }
                }
            }

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

    private static final InjectedAttributeProxy IAP_CREATED = createSysTimeStampAMD( "Created" );
    private static final InjectedAttributeProxy IAP_LAST_MOD = createSysTimeStampAMD( "LastModified" );

    private static InjectedAttributeProxy createSysTimeStampAMD( String pName )
    {
        return new InjectedAttributeProxy( pName, true, A_Timestamp.TYPE, BoAttribute.AttributeType.SimpleTimestamp );
    }

    private static class InjectedAttributeProxy implements AttributeProxy
    {
        private String mName;
        private boolean mSysSetOnly;
        private AttributeType mAttributeSetType;
        private BoAttribute.AttributeType mBoAttributeType;

        private InjectedAttributeProxy( String pName, boolean pSysSetOnly, AttributeType pAttributeSetType, BoAttribute.AttributeType pBoAttributeType )
        {
            mName = pName;
            mSysSetOnly = pSysSetOnly;
            mAttributeSetType = pAttributeSetType;
            mBoAttributeType = pBoAttributeType;
            if ( pAttributeSetType.getSimpleDataType() != pBoAttributeType.getType() )
            {
                throw new IllegalArgumentException( "Incompatible AttributeTypes Set=" + pAttributeSetType + " & " + pBoAttributeType + "=BO" );
            }
        }

        @Override
        public boolean isInjected()
        {
            return true;
        }

        @Override
        public String getDerivedFromAttribute()
        {
            return null;
        }

        @Override
        public String getName()
        {
            return mName;
        }

        @Override
        public String getColumnName()
        {
            return mName;
        }

        @Override
        public Mutability getMutability()
        {
            return Mutability.RO;
        }

        @Override
        public boolean isSysSetOnly()
        {
            return mSysSetOnly;
        }

        @Override
        public String getNotes()
        {
            return null;
        }

        @Override
        public boolean isVirtual()
        {
            return false;
        }

        @Override
        public Class getSimpleDataType()
        {
            return mAttributeSetType.getSimpleDataType();
        }

        @Override
        public String[] getValidOptions()
        {
            return null;
        }

        @Override
        public BoAttribute.AttributeType getBoAttributeType()
        {
            return mBoAttributeType;
        }

        @Override
        public AttributeType getAttributeSetType()
        {
            return mAttributeSetType;
        }

        @Override
        public boolean isRequired()
        {
            return true;
        }

        @Override
        public boolean isQueryView()
        {
            return false;
        }

        @Override
        public PropertyManager getPropertyManager()
        {
            return PropertyManager.NONE;
        }

        @Override
        public String getToManyFullyQualifiedName()
        {
            return null;
        }

        @Override
        public boolean isToManyInstantiable()
        {
            return false;
        }

        @Override
        public String getToManyBackReference()
        {
            return null;
        }

        @Override
        public AttributeProxy getToManyBackReferenceAttributeProxy()
        {
            return null;
        }

        @Override
        public String getToOneFullyQualifiedName()
        {
            return null;
        }

        @Override
        public boolean isToOneInstantiable()
        {
            return false;
        }

        @Override
        public String getToOneBackReference()
        {
            return null;
        }

        @Override
        public AttributeProxy getToOneBackReferenceAttributeProxy()
        {
            return null;
        }

        @Override
        public String toString()
        {
            return getClass().getSimpleName() + "(" + getSimpleDataType().getSimpleName() + "): " + getName();
        }
    }
}