/*******************************************************************************
 * Copyright (c) 2007, 2018 Association for Decentralized Information Management
 * in Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.db.impl.query;

import org.simantics.db.AsyncReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.RuntimeDatabaseException;
import org.simantics.db.impl.BlockingAsyncProcedure;
import org.simantics.db.impl.DebugPolicy;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.procedure.AsyncProcedure;
import org.simantics.db.request.AsyncRead;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> implements AsyncProcedure<T> {

    private static final Logger LOGGER = LoggerFactory.getLogger(AsyncReadEntry.class);

    protected AsyncRead<T> request;

    AsyncReadEntry(AsyncRead<T> request) {
        this.request = request;
        if (DebugPolicy.QUERY_STATE)
            System.out.println("[QUERY STATE]: created " + this);
    }

    @Override
    int makeHash() {
        return request.hashCode();
    }

    @Override
    public Object getOriginalRequest() {
        return request;
    }

    @Override
    public void discard() {
        super.discard();
        setResult(null);
    }

    public void except(AsyncReadGraph graph, Throwable t) {

        assert (isPending());

        synchronized (this) {
            except(t);
        }

    }

    @Override
    final public Query getQuery() {

        return new Query() {

            @Override
            public void recompute(ReadGraphImpl graph) {

                try {

                    BlockingAsyncProcedure<T> proc = new BlockingAsyncProcedure<>(graph, new AsyncProcedure<T>() {

                        @Override
                        public void execute(AsyncReadGraph graph, T result) {
                            setResult(result);
                            setReady();
                        }

                        @Override
                        public void exception(AsyncReadGraph graph, Throwable t) {
                            except(t);
                        }

                    }, request);

                    request.perform(graph, proc);

                    proc.get();

                } catch (Throwable t) {
                    except(t);
                }

            }

            @Override
            public void removeEntry(QueryProcessor qp) {
                qp.cache.remove(AsyncReadEntry.this);
            }

            @Override
            public int type() {
                return request.getFlags();
            }

            @Override
            public String toString() {
                if (request == null)
                    return "DISCARDED";
                else if (isExcepted())
                    return request.toString() + " " + getResult();
                else
                    return request.toString() + " " + statusOrException;
            }

        };

    }

    @Override
    public Object performFromCache(ReadGraphImpl graph, AsyncProcedure<T> proc) {

        if (isExcepted()) {

            try {
                proc.exception(graph, (Throwable) getResult());
            } catch (Throwable t) {
                LOGGER.error("performFromCache proc.exception failed", t);
            }

        } else {

            try {
                proc.execute(graph, (T) getResult());
            } catch (Throwable t) {
                LOGGER.error("performFromCache proc.execute failed", t);
            }

        }

        return getResult();

    }

    public static <T> void computeForEach(ReadGraphImpl parentGraph, AsyncRead<T> request, AsyncReadEntry<T> entry,
            AsyncProcedure<T> procedure_) throws DatabaseException {

        AsyncProcedure<T> procedure = entry != null ? entry : procedure_;

        ReadGraphImpl queryGraph = parentGraph.withParent(entry);
        
        BlockingAsyncProcedure<T> proc = new BlockingAsyncProcedure<>(queryGraph, new AsyncProcedure<T>() {

            @Override
            public void execute(AsyncReadGraph returnGraph, T result) {
                try {
                    procedure.execute(parentGraph, result);
                } catch (Throwable t) {
                    LOGGER.error("computeForEach procedure.execute failed", t);
                }
            }

            @Override
            public void exception(AsyncReadGraph returnGraph, Throwable t) {
                try {
                    procedure.exception(parentGraph, t);
                } catch (Throwable t2) {
                    LOGGER.error("computeForEach procedure.exception failed", t2);
                }
            }

            @Override
            public String toString() {
                return procedure.toString();
            }

        }, request);

        request.perform(queryGraph, proc);
        
        proc.get();

        if (entry != null)
            entry.performFromCache(parentGraph, procedure_);

    }

    @Override
    public String toString() {
        if (isDiscarded())
            return "DISCARDED " + request.toString();
        else if (isExcepted())
            return request.toString() + " " + getResult();
        else
            return request.toString() + " " + statusOrException;
    }

    @Override
    public void execute(AsyncReadGraph graph, T result) {
        setResult(result);
        setReady();
    }

    @Override
    public void exception(AsyncReadGraph graph, Throwable throwable) {
        except(throwable);
    }

}