package org.litesoft.aokeyhole.swing.mains.mementobeans.support;

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.textfiledirectory.*;

import java.io.*;
import java.util.*;

public class BeanWriter implements BeanMagicStrings {
    private final TextFileDirectory mTextFileDirectory;
    private final String mPackage;

    public BeanWriter( TextFileDirectory pTextFileDirectory, String pPackage ) {
        mTextFileDirectory = pTextFileDirectory;
        mPackage = pPackage;
    }

    /**
     * Persist the changes from the BeanReader to the BeanObjectBuilder (while either can be null, at least one will be not null).
     * <p/>
     * If <code>pBeanReader</code> is null, then this is a "create" Bean request,
     * Else If <code>pBuilder</code> is null, then this is a Bean "delete" request,
     * else this is an "update" Bean "request"
     *
     * @param pBeanReader Original Bean Data
     * @param pBuilder    New Bean Data
     */
    public BeanReader persist( BeanReader pBeanReader, BeanObjectBuilder pBuilder )
            throws IOException {
        if ( pBuilder == null ) {
            return delete( pBeanReader.getName() );
        }
        List<AttributeData> mergedAttributes = Lists.newArrayList();
        if ( pBeanReader == null ) {
            convertAndMergeInto( null, pBuilder.getAttributes(), mergedAttributes );
            return create( pBuilder.getName(), pBuilder.getNotes(), mergedAttributes );
        }
        boolean attributesChanged = convertAndMergeInto( pBeanReader.getAttributeDatas(), pBuilder.getAttributes(), mergedAttributes );
        if ( attributesChanged || !Currently.areEqual( pBeanReader.getNotes(), pBuilder.getNotes() ) ) {
            return update( pBuilder.getName(), pBuilder.getNotes(), mergedAttributes );
        }
        return pBeanReader;
    }

    private BeanReader delete( String pName )
            throws IOException {
        String zFileName = pName + "." + SOURCE_FILE_EXTENSION;
        mTextFileDirectory.delete( ABSTRACT_NAME_PREFIX + zFileName );
        try {
            mTextFileDirectory.delete( zFileName );
        }
        catch ( TextFileDirectory.FileDoesNotExists pFileDoesNotExists ) {
            // Ignore as some kinds of refactoring may have removed it!
        }
        return null;
    }

    private BeanReader create( String pName, String[] pNotes, List<AttributeData> pNewAttributes )
            throws IOException {
        String zFileName = pName + "." + SOURCE_FILE_EXTENSION;
        try {
            mTextFileDirectory.create( new TextFile( zFileName, getBeanLines( pName ) ) );
        }
        catch ( TextFileDirectory.FileAlreadyExists pFileAlreadyExists ) {
            // Ignore as some kinds of refactoring may have already created it!
        }
        mTextFileDirectory.create( new TextFile( ABSTRACT_NAME_PREFIX + zFileName, getAbstractBeanLines( pName, pNotes, pNewAttributes ) ) );
        return new BeanReader( pName, pNotes, pNewAttributes );
    }

    private BeanReader update( String pName, String[] pNotes, List<AttributeData> pNewAttributes )
            throws IOException {
        String zFileName = pName + "." + SOURCE_FILE_EXTENSION;
        mTextFileDirectory.update( new TextFile( ABSTRACT_NAME_PREFIX + zFileName, getAbstractBeanLines( pName, pNotes, pNewAttributes ) ) );
        return new BeanReader( pName, pNotes, pNewAttributes );
    }

    private String[] getBeanLines( String pName ) {
        return new String[]
                {
                        "package " + mPackage + ";", //
                        "", //
                        "public class " + pName + " extends Abstract" + pName, //
                        "{", //
                        "    public " + pName + "()", //
                        "    {", //
                        "    }", //
                        "", //
                        "    public " + pName + "( " + pName + " pOrig )", //
                        "    {", //
                        "        super( pOrig );", //
                        "    }", //
                        "}", //
                };
    }

    private String[] getAbstractBeanLines( String pName, String[] pNotes, List<AttributeData> zNewAttributes ) {
        List<String> zLines = Lists.newArrayList();
        zLines.add( "package " + mPackage + ";" );
        zLines.add( "" );
        if ( anyRepeating( zNewAttributes ) ) {
            zLines.add( "import org.litesoft.commonfoundation.typeutils.Objects;" );
            zLines.add( "import java.util.*;" );
            zLines.add( "" );
        }
        zLines.add( "import " + MEMENTO_BEANS_PACKAGE + ".*;" );
        zLines.add( "" );
        if ( pNotes.length != 0 ) {
            zLines.add( "/**" );
            for ( String zNote : pNotes ) {
                zLines.add( " * " + zNote );
            }
            zLines.add( " */" );
        }
        zLines.add( "@SuppressWarnings(\"UnusedDeclaration\")" );
        zLines.add( "public class Abstract" + pName + " extends AbstractMementoBean<" + pName + ">" );
        zLines.add( "{" );
        zLines.add( "    private static final AbstractAttributeProxy[] ATTRIBUTES = //" );
        zLines.add( "            { //" );
        for ( AttributeData zAttribute : zNewAttributes ) {
            zLines.add( "              " + zAttribute.toParseLine() );
        }
        zLines.add( "            };" );
        zLines.add( "" );
        zLines.add( "    protected Abstract" + pName + "()" );
        zLines.add( "    {" );
        zLines.add( "        super( ATTRIBUTES );" );
        zLines.add( "    }" );
        zLines.add( "" );
        zLines.add( "    protected Abstract" + pName + "( Abstract" + pName + " pOrig )" );
        zLines.add( "    {" );
        zLines.add( "        super( pOrig );" );
        zLines.add( "    }" );
        zLines.add( "" );
        zLines.add( "    @Override" );
        zLines.add( "    protected final " + pName + " copy()" );
        zLines.add( "    {" );
        zLines.add( "        return new " + pName + "( (" + pName + ") this );" );
        zLines.add( "    }" );
        zLines.add( "" );
        zLines.add( "    @Override" );
        zLines.add( "    protected final " + pName + " defaultInstance()" );
        zLines.add( "    {" );
        zLines.add( "        return DEFAULT_INSTANCE;" );
        zLines.add( "    }" );
        for ( AttributeData zAttribute : zNewAttributes ) {
            String zName = zAttribute.getName();
            if ( zName != null ) {
                int zID = zAttribute.getID();
                String zType = zAttribute.getType();
                zLines.add( "" );
                if ( !zAttribute.isRepeating() ) {
                    zLines.add( "    public " + zType + " get" + zName + "()" );
                    zLines.add( "    {" );
                    zLines.add( "        return getValueFor( " + zID + " );" );
                    zLines.add( "    }" );
                    zLines.add( "" );
                    zLines.add( "    public " + pName + " set" + zName + "( " + zType + " p" + zName + " )" );
                    zLines.add( "    {" );
                    zLines.add( "        return setValueFor( " + zID + ", p" + zName + " );" );
                    zLines.add( "    }" );
                } else {
                    zLines.add( "    public List<" + zType + "> get" + zName + "()" );
                    zLines.add( "    {" );
                    zLines.add( "        return getRepeatingValueFor( " + zID + " );" );
                    zLines.add( "    }" );
                    zLines.add( "" );
                    zLines.add( "    public " + pName + " clear" + zName + "()" );
                    zLines.add( "    {" );
                    zLines.add( "        return clearRepeatingValueFor( " + zID + " );" );
                    zLines.add( "    }" );
                    zLines.add( "" );
                    zLines.add( "    public " + pName + " add" + zName + "( " + zType + " p" + zName + " )" );
                    zLines.add( "    {" );
                    zLines.add( "        return addRepeatingValueFor( " + zID + ", p" + zName + " );" );
                    zLines.add( "    }" );
                    zLines.add( "" );
                    zLines.add( "    public " + pName + " set" + zName + "( List<" + zType + "> p" + zName + " )" );
                    zLines.add( "    {" );
                    zLines.add( "        return setRepeatingValueFor( " + zID + ", p" + zName + " );" );
                    zLines.add( "    }" );
                    zLines.add( "" );
                    zLines.add( "    public " + pName + " set" + zName + "( " + zType + "... p" + zName + " )" );
                    zLines.add( "    {" );
                    zLines.add( "        return setRepeatingValueFor( " + zID + ", p" + zName + " );" );
                    zLines.add( "    }" );
                }
            }
        }
        zLines.add( "" );
        zLines.add( "    public static final " + pName + " DEFAULT_INSTANCE = new " + pName + "();" );
        zLines.add( "}" );
        return zLines.toArray( new String[zLines.size()] );
    }

    private boolean anyRepeating( List<AttributeData> pAttributes ) {
        for ( AttributeData zAttribute : pAttributes ) {
            if ( zAttribute.isRepeating() ) {
                return true;
            }
        }
        return false;
    }

    /**
     * @return if there were any attribute changes
     */
    private boolean convertAndMergeInto( List<AttributeData> pPrevAttributes, List<BeanAttributeBuilder> pNewAttributes, List<AttributeData> pMergedAttributes ) {
        pPrevAttributes = ConstrainTo.notNull( pPrevAttributes );
        pNewAttributes = Lists.from( pNewAttributes ); // Copy
        boolean zChanges = false;
        int zLastIndex = -1;
        for ( AttributeData zAttribute : pPrevAttributes ) {
            zLastIndex = zAttribute.getID();
            if ( zAttribute.getName() == null ) {
                pMergedAttributes.add( zAttribute );
                continue;
            }
            BeanAttributeBuilder zNewMatch = findMatch( zAttribute, pNewAttributes );
            if ( zNewMatch == null ) {
                zChanges = true;
                pMergedAttributes.add( zAttribute.makePlaceHolder() );
                continue;
            }
            AttributeData zNewAttribute = zAttribute.updateWith( zNewMatch );
            zChanges |= (zAttribute != zNewAttribute);
            pMergedAttributes.add( zNewAttribute );
        }
        for ( BeanAttributeBuilder zNewAttribute : pNewAttributes ) {
            zChanges = true;
            pMergedAttributes.add( new AttributeData( ++zLastIndex, zNewAttribute ) );
        }
        return zChanges;
    }

    private BeanAttributeBuilder findMatch( AttributeData pAttribute, List<BeanAttributeBuilder> pNewAttributes ) {
        for ( int i = 0; i < pNewAttributes.size(); i++ ) {
            BeanAttributeBuilder zNewAttribute = pNewAttributes.get( i );
            if ( pAttribute.isUpdatableFrom( zNewAttribute ) ) {
                pNewAttributes.remove( i );
                return zNewAttribute;
            }
        }
        return null; // Not Found
    }
}