package org.litesoft.aokeyhole.objects.support;

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

public abstract class AbstractNamedMetaData<Owner extends MetaDataOwner> extends AbstractDataMetaData
{
    private Owner mOwner = null;
    private final IdentifierValidator mNameValidator;
    protected String mName;

    public AbstractNamedMetaData( String pMetaDataType, Mode pMode, boolean pEditable, IdentifierValidator pNameValidator, String pName )
    {
        super( pMetaDataType, pMode, pEditable );

        mNameValidator = pNameValidator;

        pName = trimEmptyToNull( pName );
        switch ( pMode )
        {
            case Rehydrating:
                chkUnhappyCase( validateName( pName ) );
                mName = pName;
                break;
            case New:
                if ( pName != null )
                {
                    chkUnhappyCase( validateName( pName ) );
                    mName = pName;
                }
                break;
            default:
                throw new IllegalStateException( "Unacceptable Initial Mode (" + pMode + ") for a " + getClass().getSimpleName() );
        }
    }

    public Owner getOwner()
    {
        if ( mOwner == null )
        {
            throw new IllegalStateException( getMetaDataType() + " does NOT have an owner" );
        }
        return mOwner;
    }

    public void setOwner( Owner pOwner )
    {
        mOwner = pOwner;
    }

    public SystemMetaData getSystemMetaData()
    {
        return getOwner().getSystemMetaData();
    }

    @Override
    protected void LLchanged()
    {
        super.LLchanged();
        getOwner().changed();
    }

    public IdentifierValidator getNameValidator()
    {
        return mNameValidator;
    }

    public String getName()
    {
        return mName;
    }

    /**
     * @return null or Error
     */
    public String validatePersistable()
    {
        if ( mName == null )
        {
            return "Name Required";
        }
        return super.validatePersistable();
    }

    /**
     * @return null or Error
     */
    public String setName( String pName )
    {
        verifyEditability();
        return updateName( pName );
    }

    /**
     * @return null or Error
     */
    protected String updateName( String pName )
    {
        pName = trimEmptyToNull( pName );
        String zError = validateName( pName );
        if ( (zError == null) && !pName.equals( mName ) )
        {
            getOwner().reKeyOwnedName( this, pName );
            mName = pName;
            changed();
        }
        return zError;
    }

    private String validateName( String pName )
    {
        if ( pName == null )
        {
            return "Name Required";
        }
        if ( !pName.equals( mName ) )
        {
            if ( mNameValidator != null )
            {
                String zError = mNameValidator.validateIdentifier( pName, getMetaDataType() + " Name" );
                if ( zError != null )
                {
                    return zError;
                }
            }
            if ( (mOwner != null) && mOwner.isUsedOwnedName( pName ) )
            {
                return getMetaDataType() + " with name '" + pName + "' already exists";
            }
        }
        return null;
    }

    protected StringBuilder startLine( int pIndent )
    {
        return super.startLine( pIndent ).append( ':' ).append( getName() );
    }

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