package de.intevation.artifactdatabase;

import java.util.HashMap;
import java.util.HashSet;
import java.util.ArrayList;
import java.util.List;

import de.intevation.artifacts.ArtifactDatabaseException;
import de.intevation.artifacts.ArtifactDatabase;
import de.intevation.artifacts.ArtifactFactory;
import de.intevation.artifacts.Artifact;
import de.intevation.artifacts.CallContext;

import de.intevation.artifactdatabase.Backend.PersistentArtifact;

import org.apache.log4j.Logger;

import org.w3c.dom.Document;

import java.io.OutputStream;
import java.io.IOException;

/**
 *  @author Sascha L. Teichmann
 */
public class ArtifactDatabaseImpl
implements   ArtifactDatabase, Id.Filter, Backend.FactoryLookup
{
    private static Logger logger =
        Logger.getLogger(ArtifactDatabaseImpl.class);

    public static final String NO_SUCH_FACTORY =
        "No such factory";

    public static final String NO_SUCH_ARTIFACT =
        "No such artifact";

    public static final String NOT_IN_BACKGROUND =
        "Not in background";

    public static final String INVALID_CALL_STATE =
        "Invalid after call state";

    public static final String CREATION_FAILED =
        "Creation of artifact failed";

    public static final String INTERNAL_ERROR =
        "Creation of artifact failed";

    public class CallContextImpl
    implements   CallContext
    {
        protected PersistentArtifact artifact;
        protected int                action;

        public CallContextImpl(PersistentArtifact artifact, int action) {
            this.artifact = artifact;
            this.action   = action;
        }

        public void afterCall(int action) {
            this.action = action;
            if (action == BACKGROUND) {
                addIdToBackground(artifact.getId());
            }
        }

        public void afterBackground(int action) {
            if (this.action != BACKGROUND) {
                throw new IllegalStateException(NOT_IN_BACKGROUND);
            }
            fromBackground(artifact, action);
        }

        public Object globalContext() {
            return context;
        }

        public void postCall() {
            switch (action) {
                case NOTHING:
                    break;
                case TOUCH:
                    artifact.touch();
                    break;
                case STORE:
                    artifact.store();
                    break;
                case BACKGROUND:
                    logger.warn("BACKGROUND processing is not fully implemented, yet!");
                    artifact.store();
                    break;
                default:
                    logger.error(INVALID_CALL_STATE + ": " + action);
                    throw new IllegalStateException(INVALID_CALL_STATE);
            }
        }
    } // class CallContextImpl

    public class DeferredOutputImpl
    implements   DeferredOutput
    {
        protected PersistentArtifact artifact;
        protected Document           format;

        public DeferredOutputImpl() {
        }

        public DeferredOutputImpl(
            PersistentArtifact artifact, 
            Document           format
        ) {
            this.artifact = artifact;
            this.format   = format;
        }

        public void write(OutputStream output) throws IOException {

            CallContextImpl cc = new CallContextImpl(
                artifact, CallContext.TOUCH);

            try {
                artifact.getArtifact().out(format, output, cc);
            }
            finally {
                cc.postCall();
            }
        }
    } // class DeferredOutputImpl

    protected String [][] factoryNamesAndDescription;
    protected HashMap     name2factory;

    protected Backend     backend;
    protected Object      context;

    protected HashSet     backgroundIds;

    public ArtifactDatabaseImpl() {
    }

    public ArtifactDatabaseImpl(FactoryBootstrap bootstrap) {
        this(bootstrap, null);
    }

    public ArtifactDatabaseImpl(FactoryBootstrap bootstrap, Backend backend) {

        backgroundIds = new HashSet();
        name2factory  = new HashMap();

        ArtifactFactory [] factories = bootstrap.getArtifactFactories();
        factoryNamesAndDescription = new String[factories.length][];

        for (int i = 0; i < factories.length; ++i) {

            ArtifactFactory factory = factories[i];

            String name        = factory.getName();
            String description = factory.getDescription();

            factoryNamesAndDescription[i] =
                new String [] { name, description };

            name2factory.put(name, factory);
        }

        context = bootstrap.getContext();

        wireWithBackend(backend);
    }

    public void wireWithBackend(Backend backend) {
        if (backend != null) {
            this.backend = backend;
            backend.setFactoryLookup(this);
        }
    }

    protected void fromBackground(PersistentArtifact artifact, int action) {
        logger.warn("BACKGROUND processing is not fully implemented, yet!");
        switch (action) {
            case CallContext.NOTHING:
                break;
            case CallContext.TOUCH:
                artifact.touch();
                break;
            case CallContext.STORE:
                artifact.store();
                break;
            default:
                logger.warn("operation not allowed in fromBackground");
        }
        removeIdFromBackground(artifact.getId());
    }

    protected void removeIdFromBackground(int id) {
        synchronized (backgroundIds) {
            backgroundIds.remove(Integer.valueOf(id));
        }
    }

    protected void addIdToBackground(int id) {
        synchronized (backgroundIds) {
            backgroundIds.add(Integer.valueOf(id));
        }
    }

    public List filterIds(List ids) {
        int N = ids.size();
        ArrayList out = new ArrayList(N);
        synchronized (backgroundIds) {
            for (int i = 0; i < N; ++i) {
                Id id = (Id)ids.get(i);
                if (!backgroundIds.contains(Integer.valueOf(id.getId()))) {
                    out.add(id);
                }
            }
        }
        return out;
    }

    public String [][] artifactFactoryNamesAndDescriptions() {
        return factoryNamesAndDescription;
    }

    public ArtifactFactory getArtifactFactory(String factoryName) {
        return (ArtifactFactory)name2factory.get(factoryName);
    }

    public Document createArtifactWithFactory(String factoryName)
        throws ArtifactDatabaseException 
    {
        ArtifactFactory factory = getArtifactFactory(factoryName);

        if (factory == null) {
            throw new ArtifactDatabaseException(NO_SUCH_FACTORY);
        }

        Artifact artifact = factory.createArtifact(
            backend.newIdentifier(),
            context);

        if (artifact == null) {
            throw new ArtifactDatabaseException(CREATION_FAILED);
        }

        PersistentArtifact persistentArtifact;

        try {
            persistentArtifact = backend.storeInitially(
                artifact,
                factory,
                factory.timeToLiveUntouched(artifact, context));
        }
        catch (Exception e) {
            logger.error(e.getLocalizedMessage(), e);
            throw new ArtifactDatabaseException(CREATION_FAILED);
        }

        CallContextImpl cc = new CallContextImpl(
            persistentArtifact, CallContext.NOTHING);

        try {
            return artifact.describe(cc);
        }
        finally {
            cc.postCall();
        }
    }

    public Document describe(String identifier)
        throws ArtifactDatabaseException
    {
        // TODO: Handle background tasks
        PersistentArtifact artifact = backend.getArtifact(identifier);

        if (artifact == null) {
            throw new ArtifactDatabaseException(NO_SUCH_ARTIFACT);
        }

        CallContextImpl cc = new CallContextImpl(
            artifact, CallContext.TOUCH);

        try {
            return artifact.getArtifact().describe(cc);
        }
        finally {
            cc.postCall();
        }
    }

    public Document advance(String identifier, Document target)
        throws ArtifactDatabaseException
    {
        // TODO: Handle background tasks
        PersistentArtifact artifact = backend.getArtifact(identifier);

        if (artifact == null) {
            throw new ArtifactDatabaseException(NO_SUCH_ARTIFACT);
        }

        CallContextImpl cc = new CallContextImpl(
            artifact, CallContext.STORE);

        try {
            return artifact.getArtifact().advance(target, cc);
        }
        finally {
            cc.postCall();
        }
    }

    public Document feed(String identifier, Document data)
        throws ArtifactDatabaseException
    {
        // TODO: Handle background tasks
        PersistentArtifact artifact = backend.getArtifact(identifier);

        if (artifact == null) {
            throw new ArtifactDatabaseException(NO_SUCH_ARTIFACT);
        }

        CallContextImpl cc = new CallContextImpl(
            artifact, CallContext.STORE);

        try {
            return artifact.getArtifact().feed(data, cc);
        }
        finally {
            cc.postCall();
        }
    }

    public DeferredOutput out(String identifier, Document format)
        throws ArtifactDatabaseException
    {
        // TODO: Handle background tasks
        PersistentArtifact artifact = backend.getArtifact(identifier);

        if (artifact == null) {
            throw new ArtifactDatabaseException(NO_SUCH_ARTIFACT);
        }

        return new DeferredOutputImpl(artifact, format);
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8: