package org.simantics.graph.refactoring;

import java.util.ArrayList;

import org.simantics.graph.query.Path;
import org.simantics.graph.query.PathChild;
import org.simantics.graph.query.TransferableGraphConversion;
import org.simantics.graph.query.UriUtils;
import org.simantics.graph.refactoring.MappingSpecification.MappingRule;
import org.simantics.graph.representation.External;
import org.simantics.graph.representation.Identity;
import org.simantics.graph.representation.IdentityDefinition;
import org.simantics.graph.representation.Internal;
import org.simantics.graph.representation.Optional;
import org.simantics.graph.representation.Root;
import org.simantics.graph.representation.TransferableGraph1;
import org.simantics.graph.representation.TransferableGraphUtils;
import org.simantics.graph.representation.old.OldTransferableGraph1;
import org.simantics.graph.representation.old.OldValue1;
import org.simantics.graph.store.IdentityStore;

import gnu.trove.list.array.TIntArrayList;
import gnu.trove.set.hash.TIntHashSet;

public class GraphRefactoringUtils {

    /**
     * Moves an external resource. Returns true if did something.
     * @param parentsAffected 
     */
    public static boolean moveExternal(TransferableGraph1 tg, IdentityStore ids, Path from, PathChild to, TIntHashSet parentsAffected) throws GraphRefactoringException {
        // Find from id
        int fromId = ids.pathToId(from);
        if(fromId < 0)
            return false;
        if(ids.isNewResource(fromId))
            throw new GraphRefactoringException("Cannot move internal resource " + from + ".");

        // Remove old identity
        int parentId = ids.removeIdentity(fromId);
        if(parentId >= 0)
            parentsAffected.add(parentId);

        // Find parent id
        int toParentId = ids.createPathToId(to.parent);
        if(ids.hasChild(toParentId, to.name)) {
        	System.err.println("refactor statements from " + from + " to " + to);
            //throw new GraphRefactoringException("External reference to " + to + " already exists.");
        	int toId = ids.pathToId(to);
            int[] statements = tg.statements;
            for(int i=0;i<tg.statements.length;++i) {
            	if(statements[i] == fromId) statements[i] = toId;
            }
            return true;
        }
        
        // Set new identity
        ids.setIdentity(fromId, toParentId, to.name);
        return true;
    }
    
    public static void refactor(TransferableGraph1 tg, IdentityStore ids, MappingSpecification spec, TIntHashSet parentsAffected) throws GraphRefactoringException {
        for(MappingRule rule : spec.getRules()) {
            if(!(rule.to instanceof PathChild))
                throw new GraphRefactoringException("Invalid target URI " + rule.to);
            if(!moveExternal(tg, ids, rule.from, (PathChild)rule.to, parentsAffected))
                System.err.println("Didn't find " + rule.from);
        }
    }

    public static boolean fixIncorrectRoot(Identity[] ids) {
        for(int i=0;i<ids.length;++i) {
            Identity id = ids[i];
            if(id.definition instanceof External) {
                External ext = (External)id.definition;
                if(ext.parent == -1 && (ext.name.equals("http:/") || ext.name.equals(""))) {
                    id.definition = new Root("", "");
                    return true;
                }
            }
        }
        return false;
    }

    public static void fixOntologyExport(TransferableGraph1 tg) {
    	
    	fixIncorrectRoot(tg.identities);
        fixOntologyRoot(tg, true);
        
    }
    
    public static void fixOntologyRoot(TransferableGraph1 tg, boolean tryToFix) {

    	Identity[] ids = tg.identities;
        for(int i=0;i<ids.length;++i) {
            Identity id = ids[i];
            if(id.definition instanceof Root) {
                Root ext = (Root)id.definition;
                if(ext.name.startsWith("http://")) {
                	String rootName = ext.name.substring(ext.name.lastIndexOf("/")+1);
                	String path = ext.name.substring(0, ext.name.lastIndexOf("/"));
                	Identity pathId = TransferableGraphUtils.findExternal(tg, path);
                	System.err.println("GraphRefactoringUtils.rootName=" + rootName);
                	System.err.println("GraphRefactoringUtils.path2=" + path);
                	if(pathId == null) {
                		if(!tryToFix) return;
                		IdentityStore idStore = TransferableGraphConversion.extractIdentities(tg);
                		idStore.createPathToId(UriUtils.uriToPath(path));
                		tg.resourceCount = idStore.getResourceCount();
                		tg.identities = idStore.toArray();
                		fixOntologyRoot(tg, false);
                		return;
                	} else {
	            		id.definition = new Internal(pathId.resource, rootName);
                		TIntArrayList stms = new TIntArrayList(tg.statements);
                    	Identity consistsOf = TransferableGraphUtils.findExternal(tg, "http://www.simantics.org/Layer0-1.1/ConsistsOf");
                    	Identity partOf = TransferableGraphUtils.findExternal(tg, "http://www.simantics.org/Layer0-1.1/PartOf");
                		stms.add(id.resource);
                		stms.add(partOf.resource);
                		stms.add(consistsOf.resource);
                		stms.add(pathId.resource);
                		tg.statements = stms.toArray();
                		return;
                	}
                	
                }
            }
        }
    	
    }

    public static void unfixIncorrectRoot(Identity[] ids) {
        for(int i=0;i<ids.length;++i) {
            Identity id = ids[i];
            if(id.definition instanceof Root) {
                Root root = (Root)id.definition;
                if(root.name.equals("") && root.type.equals("")) {
                    id.definition = new External(-1, "http:/");
                    return;
                }
            }
        }
    }

    public static void compactify(OldTransferableGraph1 tg,
            TIntHashSet removed) {
        // Filter removed set
        for(Identity id : tg.identities) {
            IdentityDefinition def = id.definition;
            if(def instanceof Root)
                removed.remove(id.resource);
            else if(def instanceof External)
                removed.remove(((External)def).parent);
            else if(def instanceof Internal)
                removed.remove(((Internal)def).parent);
            else if(def instanceof Optional)
                removed.remove(((Optional)def).parent);
        }
        for(int r : tg.statements)
            removed.remove(r);
        for(OldValue1 value : tg.values)
            removed.remove(value.resource);
        
        // Compactify
        if(!removed.isEmpty()) {
            // create map
            int resourceCount = tg.resourceCount;
            int[] map = new int[resourceCount];
            for(int i=0;i<resourceCount;++i)
                map[i] = i;
            for(int r : removed.toArray()) {
                map[--resourceCount] = map[r];
            }
            
            // map
            ArrayList<Identity> newIdentities = new ArrayList<Identity>(tg.identities.length);
            for(Identity id : tg.identities) {
                if(removed.contains(id.resource))
                    continue;
                else
                    newIdentities.add(id);                
                id.resource = map[id.resource];
                IdentityDefinition def = id.definition;
                if(def instanceof External) {
                    External d = (External)def;
                    d.parent = map[d.parent];
                }
                else if(def instanceof Internal) {
                    External d = (External)def;
                    d.parent = map[d.parent];
                }
                else if(def instanceof Optional) {
                    External d = (External)def;
                    d.parent = map[d.parent];
                }
            }
            tg.identities = newIdentities.toArray(new Identity[newIdentities.size()]);
            int[] statements = tg.statements;
            for(int i=0;i<statements.length;++i) {
                int r = statements[i];                        
                if(r >= 0)
                    statements[i] = map[r];
            }
            for(OldValue1 value : tg.values)
                value.resource = map[value.resource];
            tg.resourceCount = resourceCount;
        }
    }

}