package com.general.dataBase.castor;

import org.exolab.castor.jdo.Database;
import org.exolab.castor.jdo.PersistenceException;
import org.exolab.castor.jdo.Query;
import org.exolab.castor.jdo.QueryResults;

import java.util.Vector;
import java.util.Iterator;

/**
 * User: Gonzalo Abollado
 * Date: 05-ene-2004
 */
public class CastorBaseCollection
{
    private Vector vDelete;
    private Vector vObjects;
    private String sOQL;
	private String sDataBaseName;

    public CastorBaseCollection(String _sDataBaseName)
    {
	    sDataBaseName   = _sDataBaseName;
        vDelete 	    = new Vector();
		vObjects 	    = new Vector();
    }

    public CastorBaseCollection(String _sOQL, String _sDataBaseName) throws PersistenceException
    {
        this(_sDataBaseName);
        sOQL = _sOQL;
	    try
	    {
        init();
	    }
	    catch(PersistenceException _ex)
	    {
		    System.out.println("-------------------------------------------------------------");
		    System.out.println("SQL: " + _sOQL);
		    System.out.println("-------------------------------------------------------------");
		    throw _ex;
	    }
    }

    public CastorBaseCollection(String _sOQL, Database _database) throws PersistenceException
    {
        this(null);
        sOQL = _sOQL;
        init(_database);
    }

    protected void init(Database _database) throws PersistenceException
    {
        Query           query           = null;
        QueryResults    queryResult     = null;
        Object          dataObject      = null;

        query = _database.getOQLQuery(sOQL);
        queryResult = query.execute(Database.ReadOnly);
        while(queryResult.hasMore())
        {
            dataObject = queryResult.next();
            vObjects.add(dataObject);
        }
        queryResult.close();
    }

    protected void init() throws PersistenceException
    {
        Database database = null;
        try
        {
            database = CastorHelper.getDatabase(sDataBaseName);
            database.begin();
            init(database);
            database.commit();
        }
        finally
        {
            try
            {
                if(database != null && !database.isClosed())
                {
                    if(database.isActive())
                        database.rollback();
                    database.close();
                }
            }
            catch (PersistenceException e)
            {
                e.printStackTrace();
            }
        }
    }

	public boolean removeById(Integer id)
	{
		AbsCastorDataBase 	tempBaseObject 	=  null;
		Iterator iterator = null;

		if(id == null)
			return false;

		iterator = vObjects.iterator();
		while(iterator.hasNext())
		{
			tempBaseObject = (AbsCastorDataBase) iterator.next();
			if(tempBaseObject.getId().compareTo(id) == 0)
			{
				remove(tempBaseObject);
				return true;
			}
		}

		return false;
	}

    public void removeAll()
    {
        AbsCastorDataBase 	tempBaseObject 	=  null;

        for(int i=vObjects.size()-1; i>=0; i--)
        {
            tempBaseObject = (AbsCastorDataBase)vObjects.remove(i);
            addToDeleteVector(tempBaseObject);
        }
    }

	private void addToDeleteVector(AbsCastorDataBase _baseObject)
	{
		if(_baseObject.getState() != AbsCastorDataBase.STATE_NEW)
		{
		    _baseObject.setToDelete();
		    if(!vDelete.contains(_baseObject))
		        vDelete.add(_baseObject);
		}
	}

    public boolean remove(AbsCastorDataBase _baseObject)
    {
        if(vObjects.remove(_baseObject))
        {
	        addToDeleteVector(_baseObject);
            return true;
        }
        return false;
    }

    public void update() throws PersistenceException
    {
        Database database = null;

        try
        {
            database = CastorHelper.getDatabase(sDataBaseName);
            database.begin();
            update(database);
            database.commit();
        }
        catch (PersistenceException e)
        {
            e.printStackTrace();
            throw e;
        }
        finally
        {
            try
            {
                if(database != null && !database.isClosed())
                {
                    if(database.isActive())
                        database.rollback();
                    database.close();
                }
            }
            catch (PersistenceException e)
            {
                e.printStackTrace();
            }
        }

    }

    public void setToUpdate()
    {
        AbsCastorDataBase baseObject 	=  null;

        for(int i=0; i< vObjects.size(); i++)
        {
            baseObject = (AbsCastorDataBase) vObjects.get(i);
            baseObject.setToUpdate();
        }
    }

    public void update(Database _database) throws PersistenceException
    {
        AbsCastorDataBase baseObject 	=  null;

        delete(_database);
        for(int i=0; i< vObjects.size(); i++)
        {
            baseObject = (AbsCastorDataBase) vObjects.get(i);
            baseObject.update(_database);
        }
    }

    private void delete(Database _database) throws PersistenceException
    {
        AbsCastorDataBase baseObject 	=  null;

        for(int i = vDelete.size()-1; i>=0 ; i--)
        {
            baseObject = (AbsCastorDataBase) vDelete.get(i);
            baseObject.update(_database);
            vDelete.remove(i);
        }
    }

    public Iterator iterator()
    {
        return vObjects.iterator();
    }

    public int size()
    {
        return vObjects.size();
    }

    public AbsCastorDataBase find(Integer _id)
    {
        AbsCastorDataBase baseObject  = null;
        Iterator            iterator    = null;

        iterator = vObjects.iterator();
        while(iterator.hasNext())
        {
            baseObject = (AbsCastorDataBase) iterator.next();
            if(baseObject.getId().compareTo(_id) == 0)
                return baseObject;
        }

        return null;
    }

    public AbsCastorDataBase get(int _i)
    {
        return (AbsCastorDataBase)vObjects.get(_i);
    }

    public void add(AbsCastorDataBase _baseObject)
    {
        vDelete.remove(_baseObject);
        vObjects.add(_baseObject);
    }

    public boolean contains(AbsCastorDataBase _baseObject)
    {
        return vObjects.contains(_baseObject);
    }

    public int indexOf(AbsCastorDataBase _baseObject)
    {
        return vObjects.indexOf(_baseObject);
    }

    public Vector getVector()
    {
        return vObjects;
    }

    public void addAll(CastorBaseCollection _baseCollection)
    {
        vObjects.addAll(_baseCollection.getVector());
    }

    public String toString()
    {
        StringBuffer sbText = null;

        sbText = new StringBuffer();

        sbText.append("\n\tRecords: ").append(vObjects).append("\n\tDeleted: ").append(vDelete);

        return sbText.toString();
    }

}