package org.litesoft.prioritizer.server.pos;

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

import org.litesoft.core.simpletypes.*;
import org.litesoft.core.util.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.transact.*;
import org.litesoft.prioritizer.server.*;

public class Story extends StoryGO
{
    public Story( Transaction pTransaction )
    {
        super( pTransaction );
    }

    public Story( ConstructionControl pConstructionControl )
    {
        super( pConstructionControl );
    }

    @Override
    protected void transactionDisposed()
    {
        mCommitUpdate = null;
        super.transactionDisposed();
    }

    private transient StoryUpdate mCommitUpdate = null;

    @Override
    public Serializable aboutToCommit( Timestamp pTransactionTimestamp )
    {
        Transaction zTransaction = getTransaction();
        User zUser = CurrentUserAccessor.get().getRequiredUser().refreshInto( zTransaction );
        if ( isNew() )
        {
            setCreator( zUser );
        }
        else if ( isAnyAttributeChanged() && notJustPriorityLastChangedBy() )
        {
            if ( mCommitUpdate != null )
            {
                removeUpdates( mCommitUpdate );
                mCommitUpdate.requestDelete();
                mCommitUpdate = null;
            }
            addUpdates( mCommitUpdate = new StoryUpdate( zTransaction, zUser ) );
            for ( String zChangedAttributeName : getChangedAttributeNames() )
            {
                AttributeAccessorSCD<Story> zACD = getAccessorSCDrequired( zChangedAttributeName );
                if ( zACD.isPersisted() )
                {
                    if ( zACD == CD_Priority )
                    {
                        setPriorityLastChangedBy( zUser.getFullName() );
                    }
                    if ( zACD != CD_PriorityLastChangedBy )
                    {
                        String zName = zACD.getName();
                        String zOldValue = UtilsCommon.toString( getOriginalValueFor( zName ) );
                        mCommitUpdate.addChanges( new StoryChange( zTransaction, zName, zOldValue ) );
                    }
                }
            }
        }
        return super.aboutToCommit( pTransactionTimestamp );
    }

    private boolean notJustPriorityLastChangedBy()
    {
        int changes = numberOfAttributeChanged();
        return (changes > 1) || ((changes == 1) && isAttributeChanged( CD_PriorityLastChangedBy ));
    }

    private GenericReference<String> mChanges = null;

    @Override
    protected void LLclearChanges()
    {
        mChanges = GenericReference.dispose( mChanges );
    }

    @Override
    public String getChanges()
    {
        if ( mChanges == null )
        {
            mChanges = new GenericReference<String>( createChanges() );
        }
        return mChanges.get();
    }

    private String createChanges()
    {
//        return zLastUpdate == null ? null : TypeConverter.to_SimpleTimestamp( TimeRes.ToMIN, zLastUpdate.getCreated() ).toString();

        List<StoryUpdate> zUpdates = getUpdates();
        if ( zUpdates.isEmpty() )
        {
            return null;
        }
        if ( zUpdates.size() > 1 )
        {
            zUpdates = new ArrayList<StoryUpdate>( zUpdates );
            Collections.sort( zUpdates );
        }
//        return zUpdates.get( 0 );
        return null;
    }
}