/*******************************************************************************
 * Copyright (c) 2007, 2010 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.tests.api.support.undoRedoSupport;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

import org.junit.Test;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.request.ReadRequest;
import org.simantics.db.common.request.WriteRequest;
import org.simantics.db.common.utils.OrderedSetUtils;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.service.UndoRedoSupport;
import org.simantics.db.testing.base.ExistingDatabaseTest;
import org.simantics.db.tests.common.Configuration;
import org.simantics.layer0.Layer0;
import org.simantics.utils.DataContainer;

/**
 * Test case description missing!
 */
public class UndoTest09 extends ExistingDatabaseTest {
    
	@Test
    public void testUndo9() throws Exception {

    	Session session = getSession();
        final UndoRedoSupport support = session.getService(UndoRedoSupport.class);
        try {
            UndoTestOrderedSet c1 = new UndoTestOrderedSet(session, support);
            List<Resource> elements = new ArrayList<Resource>(); 
            Resource list = c1.create(elements);
            c1.check(list, elements);
            List<Resource> elements2 = new ArrayList<Resource>();
            elements2.addAll(elements);
            c1.front(list, elements2);
            c1.check(list, elements2);
            c1.back(list, elements2);
            c1.check(list, elements2);
            c1.undo();
            c1.undo();
            c1.check(list, elements);
            c1.add(list, elements);
            elements2.clear();
        } catch (Throwable t) {
            fail("Test failed with exception " + t);
        }
    }
}

class UndoTestOrderedSet {
    protected final Session session;
    protected final UndoRedoSupport support;
    protected final boolean DEBUG = Configuration.get().debug;
    UndoTestOrderedSet(Session session, UndoRedoSupport support) {
        this.session = session;
        this.support = support;
    }
    Resource create(final List<Resource> els)
    throws DatabaseException {
        final int size = 3;
        final DataContainer<Resource> subject = new DataContainer<Resource>();
        session.syncRequest(new WriteRequest() {
            @Override
            public void perform(WriteGraph g) throws DatabaseException {
                g.markUndoPoint();
                Layer0 b = Layer0.getInstance(g);
                Resource l = OrderedSetUtils.create(g, b.Type);
                subject.set(l);
                for (int i=0; i<size; ++i) {
                    g.flushCluster();
                    Resource el = g.newResource();
                    g.claim(el, b.InstanceOf, null, b.Type);
                    OrderedSetUtils.add(g, l, el);
                    els.add(el);
                }
            }
        });
        return subject.get();
    }
    void check(final Resource list, final List<Resource> els)
    throws DatabaseException {
        session.syncRequest(new ReadRequest() {
            @Override
            public void run(ReadGraph g) throws DatabaseException {
                getFirstLast(g, list, els);
            }
        });
    }
    void front(final Resource list, final List<Resource> els)
    throws DatabaseException {
        session.syncRequest(new WriteRequest() {
            @Override
            public void perform(WriteGraph g) throws DatabaseException {
                g.markUndoPoint();
                FirstLast fl = getFirstLast(g, list, els);
                if (null == fl.first)
                    return;
                OrderedSetUtils.remove(g, list, fl.last);
                OrderedSetUtils.addFirst(g, list, fl.last);
                els.remove(fl.last2);
                els.add(0, fl.last2);
            }
        });
    }
    void back(final Resource list, final List<Resource> els)
    throws DatabaseException {
        session.syncRequest(new WriteRequest() {
            @Override
            public void perform(WriteGraph g) throws DatabaseException {
                g.markUndoPoint();
                FirstLast fl = getFirstLast(g, list, els);
                if (null == fl.first)
                    return;
                OrderedSetUtils.remove(g, list, fl.first);
                OrderedSetUtils.addAfter(g, list, fl.last, fl.first);
                els.remove(fl.first2);
                els.add(els.size(), fl.first2);
            }
        });
    }
    void add(final Resource list, final List<Resource> els)
    throws DatabaseException {
        session.syncRequest(new WriteRequest() {
            @Override
            public void perform(WriteGraph g) throws DatabaseException {
                g.markUndoPoint();
                FirstLast fl = getFirstLast(g, list, els);
                if (null == fl.first)
                    return;
                Layer0 b = Layer0.getInstance(g);
                g.flushCluster();
                Resource el = g.newResource();
                g.claim(el, b.InstanceOf, null, b.Type);
                OrderedSetUtils.add(g, list, el);
                els.add(el);
            }
        });
    }
    void undo() throws DatabaseException {
        support.undo(session, 1);
    }
    class FirstLast {
        public Resource first;
        public Resource first2;
        public Resource last;
        public Resource last2;
    }
    FirstLast getFirstLast(ReadGraph g, Resource list, List<Resource> els)
    throws DatabaseException {
        ListIterator<Resource> it = OrderedSetUtils.iterator(g, list);
        int count = 0;
        Iterator<Resource> it2 = els.iterator();
        FirstLast fl = new FirstLast();
        while (it.hasNext()) {
            fl.last = it.next();
            if (null == fl.first)
                fl.first = fl.last;
            if (DEBUG)
                System.out.println("Resource " + fl.last + "in list " + list + ".");
            fl.last2 = it2.next();
            if (null == fl.first2)
                fl.first2 = fl.last2;
            if (null == fl.last2 || fl.last2.getResourceId() != fl.last.getResourceId())
                throw new DatabaseException("Error in list element rid=" + fl.last + ".");
            ++count;
        }
        if (els.size() != count)
            throw new DatabaseException("Number of ordered set elements doesn't match!");
        if (DEBUG)
            System.out.println("" + count + " elements in resource list.");
        return fl;
    }
}