package ${package};

##
## Copyright 2001-2005 The Apache Software Foundation.
##
## Licensed under the Apache License, Version 2.0 (the "License");
## you may not use this file except in compliance with the License.
## You may obtain a copy of the License at
##
##      http://www.apache.org/licenses/LICENSE-2.0
##
## Unless required by applicable law or agreed to in writing, software
## distributed under the License is distributed on an "AS IS" BASIS,
## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
## See the License for the specific language governing permissions and
## limitations under the License.
##

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import javax.jdo.Extent;
import javax.jdo.FetchPlan;
import javax.jdo.Query;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.JDOUserException;
import javax.jdo.Transaction;

// Model class imports
#foreach ( $class in $classes )
#if ( $class.getMetadata( $storeClassMetadataId ).storable && ${class.packageName} != ${package} )
import ${class.packageName}.${class.name};
#end
#end

/**
 * Generated JPox storage mechanism for ${model.name}.
 *
 * @author Mr Modello
 */
public class ${model.name}JPoxStore
{
#foreach ( $class in $classes )
#if ( $class.getMetadata( $storeClassMetadataId ).storable )
        public final static String ${class.name}_DETAIL_FETCH_GROUP = "${class.name}_detail";
#end
#end
    private static ThreadLocal threadState = new ThreadLocal();

    private PersistenceManagerFactory pmf;

    public ${model.name}JPoxStore( PersistenceManagerFactory pmf )
    {
        this.pmf = pmf;
    }

    // ----------------------------------------------------------------------
    //
    // ----------------------------------------------------------------------

    public static class ThreadState
    {
        private PersistenceManager pm;

        private Transaction tx;

        private int depth;

        public PersistenceManager getPersistenceManager()
        {
            return pm;
        }

        public Transaction getTransaction()
        {
            return tx;
        }

        public int getDepth()
        {
            return depth;
        }
    }

    // ----------------------------------------------------------------------
    // Transaction Management Methods
    // ----------------------------------------------------------------------

    public ThreadState getThreadState()
    {
        return (ThreadState) threadState.get();
    }

    public PersistenceManager begin()
    {
        ThreadState state = (ThreadState) threadState.get();

        if ( state == null )
        {
            state = new ThreadState();

            state.pm = pmf.getPersistenceManager();

            state.tx = state.pm.currentTransaction();

            state.tx.begin();

            threadState.set( state );

            return state.pm;
        }
        else
        {
            state.depth++;

            return state.pm;
        }
    }

    public void commit()
    {
        ThreadState state = (ThreadState) threadState.get();

        if ( state == null )
        {
            throw new IllegalStateException( "commit() must only be called after begin()." );
        }

        if ( state.depth > 0 )
        {
            state.depth--;

            return;
        }

        threadState.set( null );

        try
        {
            state.tx.commit();
        }
        finally
        {
            if ( state.tx.isActive() )
            {
                state.tx.rollback();
            }

            closePersistenceManager( state.pm );
        }
    }

    public void rollback()
    {
        ThreadState state = (ThreadState) threadState.get();

        if ( state == null )
        {
            // The tx is not active because it has already been committed or rolled back

            return;
        }

        threadState.set( null );

        try
        {
            if ( state.tx.isActive() )
            {
                state.tx.rollback();
            }
        }
        finally
        {
            closePersistenceManager( state.pm );
        }
    }

#foreach ( $class in $classes )
#if ( $class.getMetadata( $storeClassMetadataId ).storable )
    // ----------------------------------------------------------------------
    // ${class.name} CRUD
    // ----------------------------------------------------------------------

    public Object add${class.name}( $class.name o )
    {
        try
        {
            PersistenceManager pm = begin();

            pm.makePersistent( o );

            Object id = pm.getObjectId( o );

            commit();

            return id;
        }
        finally
        {
            rollback();
        }
    }

#if ( $class.getIdentifierFields( $version ).size() > 0 )
    public Object store${class.name}( $class.name o )
    {
        try
        {
            PersistenceManager pm = begin();

            pm.makePersistent( o );

            Object id = pm.getObjectId( o );

            commit();

            return id;
        }
        finally
        {
            rollback();
        }
    }
#end

    public void delete${class.name}( String id )
    {
        try
        {
            PersistenceManager pm = begin();

            Query query = pm.newQuery( ${class.name}.class );

            query.setIgnoreCache( true );

            // TODO: Use all known identifier fields in this filter
            query.setFilter( "this.id == \"" + id + "\"" );

            Collection result = (Collection) query.execute();

            if ( result.isEmpty() )
            {
                throw new RuntimeException( "No such object of type \"${class.name}\" with id: \"" + id + "\"." );
            }

            pm.deletePersistentAll( result );

            commit();
        }
        finally
        {
            rollback();
        }
    }

#if ( $class.getIdentifierFields( $version ).size() == 1 )
    public ${class.name} get${class.name}( String id, boolean detach )
        throws Exception
    {
        try
        {
            PersistenceManager pm = begin();

            pm.getFetchPlan().setGroup( FetchPlan.DEFAULT );

            pm.getFetchPlan().addGroup( "${class.name}_detail" );

            Query query = pm.newQuery( ${class.name}.class );

            query.setIgnoreCache( true );

            #foreach ( $idField in $class.getIdentifierFields( $version ) )
            query.setFilter( "this.${idField.name} == \"" + id + "\"" );
            #end

            Collection result = (Collection) query.execute();

            if ( result.isEmpty() )
            {
                throw new RuntimeException( "No such object of type \"${class.name}\" with id: \"" + id + "\"." );
            }

            ${class.name} object = (${class.name}) result.iterator().next();

            if ( detach )
            {
                object = (${class.name}) pm.detachCopy( object );
            }

            commit();

            return object;
        }
        finally
        {
            rollback();
        }
    }
#end

    public ${class.name} get${class.name}ByJdoId( Object id, boolean detach )
    {
        try
        {
            PersistenceManager pm = begin();

            pm.getFetchPlan().setGroup( FetchPlan.DEFAULT );

            pm.getFetchPlan().addGroup( "${class.name}_detail" );

            ${class.name} object = (${class.name}) pm.getObjectById( id, true );

            if ( detach )
            {
                object = (${class.name}) pm.detachCopy( object );
            }

            commit();

            return object;
        }
        finally
        {
            rollback();
        }
    }

    public Collection get${class.name}Collection( boolean detach, String filter, String ordering )
    {
        try
        {
            PersistenceManager pm = begin();

            Extent extent = pm.getExtent( ${class.name}.class, true );

            Query query = pm.newQuery( extent );

            if ( ordering != null )
            {
                query.setOrdering( ordering );
            }

            if ( filter != null )
            {
                query.setFilter( filter );
            }

            Collection result = ((Collection) query.execute() );

            Collection collection;

            // TODO: Why did was this done with a iterator and not makeTransientAll()? -- trygve
            //       I would guess I had to do it this way to make sure JPOX fetched all fields
            //       so this should probably go away now if detach works like expected.
            //       Also; why refresh()?
            if ( detach )
            {
                collection = new ArrayList();

                for ( Iterator it = result.iterator(); it.hasNext(); )
                {
                    Object object = it.next();

                    pm.refresh( object );

                    object = pm.detachCopy( object );

                    collection.add( object );
                }
            }
            else
            {
                collection = result;
            }

            commit();

            return collection;
        }
        finally
        {
            rollback();
        }
    }
#end

#end

    public ${model.name}ModelloMetadata get${model.name}ModelloMetadata( boolean detach )
    {
        try
        {
            PersistenceManager pm = begin();

            pm.getFetchPlan().setGroup( FetchPlan.DEFAULT );

            Query query = pm.newQuery( ${model.name}ModelloMetadata.class );

            query.setIgnoreCache( true );

            Collection result = (Collection) query.execute();

            if ( result.isEmpty() )
            {
                return null;
            }

            ${model.name}ModelloMetadata object = (${model.name}ModelloMetadata) result.iterator().next();

            if ( detach )
            {
                object = (${model.name}ModelloMetadata) pm.detachCopy( object );
            }

            commit();

            return object;
        }
        finally
        {
            rollback();
        }
    }

    public void store${model.name}ModelloMetadata( ${model.name}ModelloMetadata o )
    {
        try
        {
            PersistenceManager pm = begin();

            pm.makePersistent( o );

            commit();
        }
        finally
        {
            rollback();
        }
    }

    public void eraseModelFromDatabase()
    {
        try
        {
            PersistenceManager pm = begin();

            Query query = pm.newQuery( ${model.name}ModelloMetadata.class );

            query.setIgnoreCache( true );

            query.deletePersistentAll();

            #foreach ($class in $classes)
            query = pm.newQuery( ${class.name}.class );

            query.setIgnoreCache( true );

            query.deletePersistentAll();
            #end


            commit();
        }
        finally
        {
            rollback();
        }
    }

    // ----------------------------------------------------------------------
    // Utility Methods
    // ----------------------------------------------------------------------

    private void closePersistenceManager( PersistenceManager pm )
    {
        try
        {
            pm.close();
        }
        catch( JDOUserException ex )
        {
            ex.printStackTrace();
        }
    }
}