// This Source Code is in the Public Domain per: http://unlicense.org
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
     */
    @Override
    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 ) ) {
            //noinspection unchecked
            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;
    }

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