/*******************************************************************************
 * 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.RelationInfo;
import org.simantics.db.common.exception.DebugException;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.impl.procedure.InternalProcedure;
import org.simantics.db.impl.procedure.TripleIntProcedureAdapter;
import org.simantics.db.procedure.ListenerBase;
import org.simantics.db.request.RequestFlags;

public final class Statements extends CollectionBinaryQuery<TripleIntProcedure> implements TripleIntProcedure {

    public Statements(final int r1, final int r2) {
        super(r1, r2);
    }

    final public static void queryEach(ReadGraphImpl graph, final int r1, final int r2, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException {

        assert(r1 != 0);
        assert(r2 != 0);

        if(parent == null && listener == null) {
            Statements.computeForEach(graph, r1, r2, null, procedure);
            return;
        }

        QueryCache.runnerStatements(graph, r1, r2, parent, listener, procedure);

    }

    @Override
    final public void removeEntry(QueryProcessor provider) {
        provider.cache.remove(this);
    }

    final static TripleIntProcedure NOPT = new TripleIntProcedure() {


        @Override
        public void exception(ReadGraphImpl graph, Throwable throwable) {
        }

        @Override
        public void execute(ReadGraphImpl graph, int s, int p, int o) {
        }

        @Override
        public void finished(ReadGraphImpl graph) {
        }

    };

    final static private IntArray getAssertionMap(ReadGraphImpl graph, final int r1, final int r2, final Statements entry) throws DatabaseException {

        class AssertionMapProc implements IntProcedure {

            boolean first = true;

            private IntArray result;

            public void addStatement(int s, int p, int o) {

                if(result.size() == 0) {
                    result.add(s);
                    result.add(p);
                    result.add(o);
                } else {
                    for(int i = 0;i < result.sizeOrData ; i+=3) {
                        int existingP = result.data[i+1];
                        if(p == existingP) {
                            int existingO = result.data[i+2];
                            if(existingO == o) return;
                        }
                    }
                    result.add(s);
                    result.add(p);
                    result.add(o);
                }

            }

            @Override
            public void execute(ReadGraphImpl graph, int type) throws DatabaseException {
                if(result == null) {
                    result = QueryCache.resultAssertedStatements(graph, type, r2, entry, null);
                } else {
                    if (first) {
                        IntArray ia = result;
                        result = new IntArray();
                        if(ia.data != null) {
                            for(int i = 0;i < ia.sizeOrData ; i+=3) addStatement(ia.data[i],ia.data[i+1],ia.data[i+2]);
                        }
                        first = false;
                    }
                    IntArray ia = QueryCache.resultAssertedStatements(graph, type, r2, entry, null);
                    if(ia.data != null) {
                        for(int i = 0;i < ia.sizeOrData ; i+=3) addStatement(ia.data[i],ia.data[i+1],ia.data[i+2]);
                    }
                }
            }

            @Override
            public void finished(ReadGraphImpl graph) {
            }

            @Override
            public void exception(ReadGraphImpl graph, Throwable throwable) {
            }

        }

        AssertionMapProc amp = new AssertionMapProc();

        // This dependency could be cut
        QueryCache.runnerPrincipalTypes(graph, r1, entry, null, amp);

        return amp.result;

    }

    final static private void forSingleAssertion(ReadGraphImpl graph, final int r1, final int r2, final Statements parent, final TripleIntProcedure procedure) throws DatabaseException {

        IntArray map = getAssertionMap(graph, r1, r2, parent);
        if(map == null) {
            procedure.finished(graph);
            return;
        }

        int size = map.size();
        if(size == 3) {

            int s = map.data[0];
            int p = map.data[1];
            int o = map.data[2];

            procedure.execute(graph, s,p,o);
            procedure.finished(graph);

        } else if(size == 0) {

            procedure.finished(graph);

        } else {

            int candidateS = map.data[0];
            int candidateP = map.data[1];
            int candidateO = map.data[2];

            IntSet candidateIs = null;
            try {
                candidateIs = QueryCache.resultSuperTypes(graph, candidateS, parent, null);
            } catch (DatabaseException e) {
                procedure.exception(graph, e);
                return;
            }

            for(int i=3;i<map.size();i+=3) {

                int nextS = map.data[i];
                int nextP = map.data[i+1];
                int nextO = map.data[i+2];

                if(nextS != candidateS) {

                    if(candidateIs.contains(nextS)) {

                        // Next is a super type of candidate => ignore next

                    } else {

                        IntSet nextIs = null;
                        try {
                            nextIs = QueryCache.resultSuperTypes(graph, nextS, parent, null);
                        } catch (DatabaseException e) {
                            procedure.exception(graph, e);
                            return;
                        }

                        if(nextIs.contains(candidateS)) {

                            // Candidate is a super type of next => next is the new candidate

                            candidateS = nextS;
                            candidateP = nextP;
                            candidateO = nextO;
                            candidateIs = nextIs;

                        } else {
                            // candidate and next are unrelated => error
                            ManyObjectsForFunctionalRelationException exception = new ManyObjectsForFunctionalRelationException("Functional relation has conflicting assertions.", r1);
                            procedure.exception(graph, exception);
                            return;	        				
                        }

                    }

                }

            }

            procedure.execute(graph, candidateS, candidateP, candidateO);
            procedure.finished(graph);

        }

    }

    final static InternalProcedure<IntSet> NOP = new InternalProcedure<IntSet>() {

        @Override
        public void execute(ReadGraphImpl graph, IntSet result) {
        }

        @Override
        public void exception(ReadGraphImpl graph, Throwable throwable) {
        }

    };

    // Search for one statement
    final static public void computeFunctionalIndex(ReadGraphImpl graph, final int r1, final int r2, final Statements parent, final RelationInfo ri, final TripleIntProcedure procedure) throws DatabaseException {

        if(ri.isFinal) {

            int result = graph.processor.querySupport.getFunctionalObject(r1, r2);

            if(result == 0) {

                // Check for assertions
                forSingleAssertion(graph, r1, r2, parent, procedure);

            } else if(result == -1) {

                graph.processor.querySupport.getObjects(graph, r1, r2, new IntProcedure() {

                    @Override
                    public void execute(ReadGraphImpl graph, int i) throws DatabaseException {
                        procedure.execute(graph, r1, r2, i);
                    }

                    @Override
                    public void exception(ReadGraphImpl graph, Throwable t) {
                        if(DebugException.DEBUG) new DebugException(t).printStackTrace();
                    }

                    @Override
                    public void finished(ReadGraphImpl graph) {
                    }

                });

                // Check for assertions
                forSingleAssertion(graph, r1, r2, parent, procedure);

            } else {

                // If functional relation was found there is no need to check assertions
                procedure.execute(graph, r1, r2, result);
                procedure.finished(graph);

            }


        } else {

            // Note! The dependency is intentionally cut!
            IntSet direct = QueryCache.resultDirectPredicates(graph, r1, null, null);
            direct.forEach(graph, new SyncIntProcedure() {

                /*
                 * 0 = not found
                 * 1 = found
                 * 2 = exception
                 */
                int found = 0;

                @Override
                public void run(ReadGraphImpl graph) throws DatabaseException {

                    if(found == 1) {

                        procedure.finished(graph);

                    } else if(found == 0) {

                        // Check for assertions
                        forSingleAssertion(graph, r1, r2, parent, procedure);

                    }

                }

                @Override
                public void execute(ReadGraphImpl graph, final int pred) throws DatabaseException {

                    if(found > 0)
                        return;

                    if(pred == r2) {

                        // Note! The dependency is intentionally cut!
                        QueryCache.runnerDirectObjects(graph, r1, pred, null, null, new IntProcedure() {

                            @Override
                            public void execute(ReadGraphImpl graph, int i) throws DatabaseException {

                                if(found == 0) {

                                    procedure.execute(graph, r1, pred, i);
                                    found = 1;

                                } else {

                                    ManyObjectsForFunctionalRelationException exception = new ManyObjectsForFunctionalRelationException("Functional relation has more than one statement.", r1);
                                    procedure.exception(graph, exception);
                                    found = 2;

                                }

                            }

                            @Override
                            public void finished(ReadGraphImpl graph) throws DatabaseException {
                            }

                            @Override
                            public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {

                                procedure.exception(graph, t);
                                found = 2;

                            }

                        });

                    } else {

                        QueryCache.runnerSuperRelations(graph, pred, parent, null, new InternalProcedure<IntSet>() {

                            @Override
                            public void execute(ReadGraphImpl graph, IntSet result) throws DatabaseException {

                                if(found > 0)
                                    return;

                                if(result.contains(r2)) {

                                    inc();

                                    // Note! The dependency is intentionally cut!
                                    QueryCache.runnerDirectObjects(graph, r1, pred, null, null, new IntProcedure() {

                                        @Override
                                        public void execute(ReadGraphImpl graph, int i) throws DatabaseException {

                                            if(found == 0) {

                                                procedure.execute(graph, r1, pred, i);
                                                found = 1;

                                            } else {

                                                ManyObjectsForFunctionalRelationException exception = new ManyObjectsForFunctionalRelationException("Functional relation has more than one statement (r1=" + r1 + ", r2=" + r2 + ").", r1);
                                                procedure.exception(graph, exception);
                                                found = 2;

                                            }

                                        }

                                        @Override
                                        public void finished(ReadGraphImpl graph) throws DatabaseException {
                                        }

                                        @Override
                                        public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
                                            procedure.exception(graph, t);
                                            found = 2;
                                        }

                                    });

                                }

                            }

                            @Override
                            public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
                                procedure.exception(graph, t);
                                found = 2;
                            }

                        });

                    }

                }

                @Override
                public void finished(ReadGraphImpl graph) throws DatabaseException {
                    dec(graph);
                }

            });

        }

    }

    final static private void forAssertions(ReadGraphImpl graph, final int r1, final int r2, final Statements parent, final TripleIntProcedure procedure) throws DatabaseException {

        QueryCache.runnerPrincipalTypes(graph, r1, parent, null, new SyncIntProcedure() {

            @Override
            public void run(ReadGraphImpl graph) throws DatabaseException {
                procedure.finished(graph);
            }

            TripleIntProcedure proc = new TripleIntProcedureAdapter() {

                @Override
                public void execute(ReadGraphImpl graph, int s, int p, int o) throws DatabaseException {
                    procedure.execute(graph, s, p, o);
                }

                @Override
                public void finished(ReadGraphImpl graph) throws DatabaseException {
                    dec(graph);
                }

                @Override
                public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
                    dec(graph);
                    procedure.exception(graph, t);
                }

            }; 

            @Override
            public void execute(ReadGraphImpl graph, int type) throws DatabaseException {
                inc();
                QueryCache.runnerAssertedStatements(graph, type, r2, parent, null, proc);
            }

            @Override
            public void finished(ReadGraphImpl graph) throws DatabaseException {
                dec(graph);       
            }

            @Override
            public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
                dec(graph);
            }

        });


    }

    final static public void computeNotFunctionalIndex(ReadGraphImpl graph, final int r1, final int r2, final Statements parent, final RelationInfo ri, final TripleIntProcedure procedure) throws DatabaseException {

        if(ri.isFinal) {

            graph.processor.querySupport.getObjects(graph, r1, r2, new IntProcedure() {

                @Override
                public void execute(ReadGraphImpl graph, int i) throws DatabaseException {
                    procedure.execute(graph, r1, r2, i);
                }

                @Override
                public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
                    if(DebugException.DEBUG) new DebugException(t).printStackTrace();
                    procedure.exception(graph, t);
                }

                @Override
                public void finished(ReadGraphImpl graph) {
                }

            });

            if(ri.isAsserted) {
                forAssertions(graph, r1, r2, parent, procedure);
            } else {
                procedure.finished(graph);
            }

        } else {

            // Note! The dependency is intentionally cut!
            IntSet direct = QueryCache.resultDirectPredicates(graph, r1, null, null);
            direct.forEach(graph, new SyncIntProcedure() {

                @Override
                public void run(ReadGraphImpl graph) throws DatabaseException {
                    forAssertions(graph, r1, r2, parent, procedure);
                }

                @Override
                public void execute(ReadGraphImpl graph, final int pred2) throws DatabaseException {

                    if(pred2 == r2) {

                        // Note! The dependency is intentionally cut!
                        QueryCache.runnerDirectObjects(graph, r1, pred2, null, null, new IntProcedure() {

                            @Override
                            public void execute(ReadGraphImpl graph, int i) throws DatabaseException {
                                procedure.execute(graph, r1, pred2, i);
                            }

                            @Override
                            public void finished(ReadGraphImpl graph) throws DatabaseException {
                            }

                            @Override
                            public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
                                procedure.exception(graph, t);
                            }

                        });

                    } else {

                        try {

                            IntSet result = QueryCache.resultSuperRelations(graph, pred2, parent, null);
                            if(result.contains(r2)) {

                                inc();

                                // Note! The dependency is intentionally cut!
                                QueryCache.runnerDirectObjects(graph, r1, pred2, null, null, new IntProcedure() {

                                    @Override
                                    public void execute(ReadGraphImpl graph, int i) throws DatabaseException {
                                        procedure.execute(graph, r1, pred2, i);

                                    }

                                    @Override
                                    public void finished(ReadGraphImpl graph) throws DatabaseException {
                                        dec(graph);
                                    }

                                    @Override
                                    public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
                                        procedure.exception(graph, t);
                                        dec(graph);
                                    }

                                });

                            }

                        } catch (Throwable e) {
                            procedure.exception(graph, e);
                        }

                    }

                }

                @Override
                public void finished(ReadGraphImpl graph) throws DatabaseException {
                    dec(graph);
                }

            });

        }

    }

    public static void computeForEach(ReadGraphImpl graph, final int r1, final int r2, final Statements entry, final TripleIntProcedure procedure_) throws DatabaseException {

        TripleIntProcedure procedure = entry != null ? entry : procedure_;

        RelationInfo ri = QueryCache.resultRelationInfoQuery(graph, r2, entry, null);
        graph.ensureLoaded(r1, r2);
        if(ri.isFunctional) {
            computeFunctionalIndex(graph, r1, r2, entry, ri, procedure);
        } else {
            computeNotFunctionalIndex(graph, r1, r2, entry, ri, procedure);
        }

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

    }

    @Override
    public String toString() {
        return "Statements[" + r1() + " - " + r2() + "]";
    }

    final private void finish(ReadGraphImpl graph, TripleIntProcedure procedure) throws DatabaseException {

        assert(assertPending());

        synchronized(this) {
            setReady();
            //new Exception(toString() + " is READY").printStackTrace();
        }

        IntArray v = (IntArray)getResult();
        final IntArray value = (IntArray)getResult();

        for(int i=0;i<value.size();i+=3) {
            procedure.execute(graph, value.data[i], value.data[i+1], value.data[i+2]);
        }

        procedure.finished(graph);

    }

    synchronized public void addOrSet(int s, int p, int o) {

        assert(assertPending());

        IntArray value = (IntArray)getResult();
        value.add(s);
        value.add(p);
        value.add(o);

    }

    final static public int r1(long id) {
        return (int)(id>>>32);
    }

    final static public int r2(long id) {
        return (int)id;
    }

    final public void addOrSetFunctional(int s, long po) {

        addOrSetFunctional(s, r1(po), r2(po));

    }

    final public void addOrSetFunctional(int s, int p, int o) {

        assert(assertPending());

        IntArray value = (IntArray)getResult();
        value.add(s);
        value.add(p);
        value.add(o);

    }

    @Override
    public Object performFromCache(ReadGraphImpl graph, final TripleIntProcedure procedure) throws DatabaseException {

        assert(isReady());

        final IntArray value = (IntArray)getResult();

        if(handleException(graph, procedure)) return value;

        for(int i=0;i<value.size();i+=3) {
            procedure.execute(graph, value.data[i], value.data[i+1], value.data[i+2]);
        }

        procedure.finished(graph);

        return value;

    }

    @Override
    public void recompute(ReadGraphImpl graph) throws DatabaseException {

        computeForEach(graph, r1(), r2(), this, new TripleIntProcedureAdapter() {

            @Override
            public void finished(ReadGraphImpl graph) {
            }

            @Override
            public void exception(ReadGraphImpl graph, Throwable t) {
                new Error("Error in recompute.", t).printStackTrace();
            }

        });

    }

    @Override
    public int type() {
        return RequestFlags.IMMEDIATE_UPDATE;
    }


    @Override
    boolean isImmutable(ReadGraphImpl graph) {
        return graph.processor.isImmutable(r1());
    }

    @Override
    public void execute(ReadGraphImpl graph, int s, int p, int o) throws DatabaseException {
        addOrSet(s, p, o);
    }

    @Override
    public void finished(ReadGraphImpl graph) throws DatabaseException {
        setReady();
    }

    @Override
    public void exception(ReadGraphImpl graph, Throwable throwable) throws DatabaseException {
        except(throwable);
    }

}