package com.c2kernel.graph.model;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Observable;
import java.util.Stack;

import com.c2kernel.graph.event.EntireModelChangedEvent;
import com.c2kernel.graph.event.ForcedNotifyEvent;
import com.c2kernel.graph.event.GraphModelEvent;
import com.c2kernel.utils.Logger;


public class GraphModelManager extends Observable
{

    private GraphModel mGraphModel;
    private EdgeFactory mEdgeFactory;
    private VertexFactory mVertexFactory;
    private VertexOutlineCreator mVertexOutlineCreator;
    private EntireModelChangedEvent     mEntireModelChangedEvent     = new EntireModelChangedEvent();
    private ForcedNotifyEvent           mForcedNotifyEvent           = new ForcedNotifyEvent();
    private Stack<GraphModel>                       mParentModels                 = new Stack<GraphModel>();
    private ArrayList<Integer>                   mParentIds                    = new ArrayList<Integer>();
    private boolean                    mEditable                     = true;

    // Calling this constructor does not create a vertex outline creator
    // which is required by the method addVertexAndCreateId()
    public GraphModelManager()
    {
        mGraphModel = new GraphModel();
        mGraphModel.setManager(this);
    }

    public GraphModelManager(GraphModel newModel) {
        newModel.setManager(this);
        mGraphModel = newModel;
    }

    public void replace(GraphModel newModel) {
        mParentModels.clear();

        //zoom back to where we were
        for (Iterator<Integer> iter = mParentIds.iterator(); iter.hasNext();) {
            Integer parentId = iter.next();
            GraphableVertex childModelVertex = (GraphableVertex)newModel.getVertexById(parentId.intValue());
            if (childModelVertex == null) { // we've been deleted, stay here
                Logger.msg(7, "Didn't find "+parentId+" in new model tree. Stopping here.");
                do { iter.remove(); } while (iter.hasNext());
                break;
            }
            else {
                mParentModels.push(newModel);
                Logger.msg(7, "Pushing model and switching to "+parentId);
                newModel = childModelVertex.getChildGraphModel();
            }
        }
        setModel(newModel);
    }

    public void setModel(GraphModel newModel) {
        // reset transient data
        newModel.mSelection           = new Selection(null, null, 0, 0, 0, 0);
        newModel.mNewEdgeOriginVertex = null;
        newModel.mNewEdgeEndPoint     = null;

        // copy factories over
        newModel.setExternalEdgeFactory(mEdgeFactory);
        newModel.setExternalVertexFactory(mVertexFactory);
        newModel.setVertexOutlineCreator(mVertexOutlineCreator);
        mVertexFactory.setCreationContext(newModel.getContainingVertex());
        newModel.setManager(this);
        mGraphModel.setManager(null);
        mGraphModel = newModel;

        // notify
        setChanged();
        notifyObservers(mEntireModelChangedEvent);
    }

    public void zoomIn(Vertex child) {
        GraphModel childModel = child.getChildGraphModel();
        if (childModel != null) {
            mParentModels.push(mGraphModel);
            mParentIds.add(new Integer(child.getID()));
            setModel(childModel);
            Logger.msg(7, "ZoomIn - Stack size: "+mParentModels.size()+" ids:"+mParentIds.size());
        }
    }

    public void zoomOut() {
        if (!mParentModels.empty()) {
            setModel(mParentModels.pop());
            mParentIds.remove(mParentIds.size()-1);
        }
        Logger.msg(7, "ZoomOut - Stack size: "+mParentModels.size()+" ids:"+mParentIds.size());

    }

    public void forceNotify()
    {
        setChanged();
        notifyObservers(mForcedNotifyEvent);
    }

    public GraphModel getModel() {
        return mGraphModel;
    }

    public void setExternalEdgeFactory(EdgeFactory newEdgeFactory) {
        mEdgeFactory = newEdgeFactory;
        mGraphModel.setExternalEdgeFactory(newEdgeFactory);
    }

    public void setExternalVertexFactory(VertexFactory newVertexFactory) {
        mVertexFactory = newVertexFactory;
        mGraphModel.setExternalVertexFactory(newVertexFactory);
    }

    public void setVertexOutlineCreator(VertexOutlineCreator newVertexOutlineCreator) {
        mVertexOutlineCreator = newVertexOutlineCreator;
        mGraphModel.setVertexOutlineCreator(newVertexOutlineCreator);
    }

    @Override
	protected void setChanged() {
        super.setChanged();
    }

    protected void notifyObservers(GraphModelEvent ev) {
        super.notifyObservers(ev);
    }

    public void setEditable(boolean editable) {
        mEditable = editable;
    }

    public boolean isEditable() {
        return mEditable;
    }


}