/*******************************************************************************
 * Copyright (c) 2013 Laboratory for Internet Computing, University of Cyprus.
 * 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
 *
 * Initial development of the original code was made for the 
 * CELAR project founded by European Union
 * project number: FP7-317790  http://www.celarcloud.eu
 *
 * Contributors:
 *   Stalo Sofokleous - initial API and implementation
 *   Nicholas Loulloudes - API and implementation extensions
 *   
 *******************************************************************************/
package org.eclipse.camf.tosca.editor;


import org.eclipse.camf.core.model.CloudModel;
import org.eclipse.camf.core.model.ICloudElement;
import org.eclipse.camf.tosca.DefinitionsType;
import org.eclipse.camf.tosca.DocumentRoot;
import org.eclipse.camf.tosca.ImplementationArtifactType;
import org.eclipse.camf.tosca.SourceElementType;
import org.eclipse.camf.tosca.TArtifactTemplate;
import org.eclipse.camf.tosca.TDeploymentArtifact;
import org.eclipse.camf.tosca.TNodeTemplate;
import org.eclipse.camf.tosca.TNodeTypeImplementation;
import org.eclipse.camf.tosca.TRelationshipTemplate;
import org.eclipse.camf.tosca.TServiceTemplate;
import org.eclipse.camf.tosca.TTopologyTemplate;
import org.eclipse.camf.tosca.TargetElementType;
import org.eclipse.camf.tosca.core.TOSCAResource;
import org.eclipse.camf.tosca.editor.listener.ToscaModelChangeListener;
import org.eclipse.camf.tosca.elasticity.TNodeTemplateExtension;
import org.eclipse.camf.tosca.elasticity.TServiceTemplateExtension;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.draw2d.IFigure;
import org.eclipse.emf.common.command.BasicCommandStack;
import org.eclipse.emf.common.util.BasicDiagnostic;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.LayerConstants;
import org.eclipse.gef.editparts.LayerManager;
import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
import org.eclipse.graphiti.features.IAddFeature;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
import org.eclipse.graphiti.features.context.impl.AddContext;
import org.eclipse.graphiti.features.context.impl.AreaContext;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.ChopboxAnchor;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.platform.IDiagramBehavior;
//import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.ui.editor.DiagramEditor;
import org.eclipse.graphiti.ui.editor.DiagramEditorInput;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.PartInitException;


/**
 * @author Nicholas Loulloudes
 *
 */
public class ToscaDiagramEditor extends DiagramEditor {
	  
	  private static GraphicalViewer gViewer;
	  
	  public static IDiagramBehavior db = null;
	  
	  private ToscaModelChangeListener toscaModelChangeListener;
	  
	  private TransactionalEditingDomain transactionalEditingDomain;
	  
	  private static IProject activeProject = null;
	    
	  /**
	   * The Tosca Diagram Editor Constructor.
	   */
	  public ToscaDiagramEditor () {
		  
	    super ();
	    
	  }
	   
	  public static IProject getActiveProject(){
	    
	    return activeProject;
	    
	  }
	  
	  protected void registerBusinessObjectsListener() {
	    
	    this.toscaModelChangeListener = new ToscaModelChangeListener(this);

	    final TransactionalEditingDomain ted = getEditingDomain();
	    ted.addResourceSetListener(this.toscaModelChangeListener);
	  }

	  /* (non-Javadoc)
	   * @see org.eclipse.graphiti.ui.editor.DiagramEditor#getEditingDomain()
	   */
	  @Override
	  public TransactionalEditingDomain getEditingDomain() {
	    TransactionalEditingDomain ted = super.getEditingDomain();

	    if (ted == null) {
	      ted = this.transactionalEditingDomain;
	    }

	    return ted;
	  }

	  @Override
	  public void init(final IEditorSite site, final IEditorInput input) throws PartInitException {
	    
	    IEditorInput finalInput = null;

	    try {
	      if (input instanceof ToscaDiagramEditorInput) {
	        finalInput = input;
	      } else {
	        finalInput = createNewDiagramEditorInput(input);
	      }
	    } catch (CoreException exception) {
	      exception.printStackTrace();
	    }

	    if ( finalInput instanceof ToscaDiagramEditorInput ){
	      activeProject = ((ToscaDiagramEditorInput) finalInput).getToscaFile().getProject();
	    }

	    super.init(site, finalInput);
	    // Refresh Palette Compartments
	    ToscaDiagramEditor.db = getDiagramTypeProvider().getFeatureProvider().getDiagramTypeProvider().getDiagramBehavior();
	    getDiagramTypeProvider().getFeatureProvider().getDiagramTypeProvider().getDiagramBehavior().refreshPalette();
	    
	  }
	  

	  private ToscaDiagramEditorInput createNewDiagramEditorInput(final IEditorInput input) throws CoreException {

	    final IFile dataFile = ToscaFileService.getDataFileForInput(input);

	    // now generate the temporary diagram file
	    final IPath dataFilePath = dataFile.getFullPath();

	    // get or create the corresponding temporary folder
	    final IFolder tempFolder = ToscaFileService.getOrCreateTempFolder(dataFilePath);

	    // finally get the diagram file that corresponds to the data file
	    final IFile diagramFile = ToscaFileService.getTemporaryDiagramFile(dataFilePath, tempFolder);

	    // Create new temporary diagram file
	    ToscaDiagramCreator creator = new ToscaDiagramCreator();

	    return creator.createToscaDiagram(dataFile, diagramFile, this, false);
	  }
	  
	  @Override
	  public void doSave(final IProgressMonitor monitor) {
	    super.doSave(monitor);
	    
//	    final ToscaDiagramEditorInput tdei = (ToscaDiagramEditorInput) getEditorInput();
	    
	    ((BasicCommandStack) getEditingDomain().getCommandStack()).saveIsDone();
	    updateDirtyState();
	  }
	  
	  @Override
	  public boolean isDirty() {
	    TransactionalEditingDomain editingDomain = getEditingDomain();
	    // Check that the editor is not yet disposed
	    if (editingDomain != null && editingDomain.getCommandStack() != null) {
	      return ((BasicCommandStack) editingDomain.getCommandStack()).isSaveNeeded();
	    }
	    return false;
	  }
	  
	  @Override
	  protected void setInput(final IEditorInput input) {
	    super.setInput(input);

	    final ToscaDiagramEditorInput tdei = (ToscaDiagramEditorInput) input;
	    final IFile dataFile = tdei.getToscaFile();
	    
	    final ToscaModelLayer model = new ToscaModelLayer(getDiagramTypeProvider().getFeatureProvider(), dataFile);
	    ModelHandler.addModel(EcoreUtil.getURI(getDiagramTypeProvider().getDiagram()), model);
	    
	    DocumentRoot documentRoot = null;
	    TOSCAResource toscaResource = null ;
	    ICloudElement findElement = CloudModel.getRoot().findElement( dataFile );
	    if (findElement instanceof TOSCAResource) {
	      toscaResource = (TOSCAResource) findElement;
	    }
	    
	    URI resourceURI = null;
	    //IEditorInput eInput = getEditorInput();
	   
	    if( getEditorInput() instanceof ToscaDiagramEditorInput ) {
	      IFile modelFile = ((ToscaDiagramEditorInput) getEditorInput()).getToscaFile();      
	      resourceURI = URI.createPlatformResourceURI( modelFile.getFullPath().toString(), false );      
	    } 
	    
	    Exception exception = null;
	    Resource resource = null;
	    try {
	      /* Load the resource through the editing domain. */
	      resource = getEditingDomain().getResourceSet().getResource( resourceURI, true );
	    } catch( Exception e ) {
	      exception = e;
	      resource = getEditingDomain().getResourceSet().getResource( resourceURI, false );
	    }
	    Diagnostic diagnostic = analyzeResourceProblems( resource, exception );
	        
	    if( diagnostic.getSeverity() != Diagnostic.OK ) {
	      //todo
	    } else {
	      documentRoot = getDocumentRoot( resource );
//	      documentRoot = toscaResource.getTOSCAModel().getDocumentRoot();
	    }

	    
	    if( documentRoot != null ) {
	      model.setDocumentRoot( documentRoot );
	      BasicCommandStack basicCommandStack = ( BasicCommandStack )getEditingDomain().getCommandStack();
	      if( input instanceof DiagramEditorInput ) {
	        basicCommandStack.execute( new RecordingCommand( getEditingDomain() ) {

	          @Override
	          protected void doExecute() {
	            importDiagram( model );
	          }
	        } );
	      }
	      basicCommandStack.saveIsDone();
	      basicCommandStack.flush();
	    }
	  }
	  
	  private final DocumentRoot getDocumentRoot( final Resource resource ) {
	    // Get an iterator to iterate through all contents of the resource.
	    TreeIterator<EObject> iterator = resource.getAllContents();
	    DocumentRoot result = null;
	    while( iterator.hasNext() ) {
	      EObject testElement = iterator.next();
	      /*
	       * Instance-of checks for each EObject that appears in the resource. We
	       * want to get the DocumentRoot EObject which is the root Element inside a
	       * Tosca Document.
	       */
	      if( testElement instanceof DocumentRoot ) {
	        result = ( DocumentRoot ) testElement;
	      }
	    }
	    return result;
	  }
	  
	  
	  /**
	   * @param resource
	   * @param exception
	   * @return
	   */
	  private Diagnostic analyzeResourceProblems( final Resource resource,
	                                             final Exception exception )
	  {
	    Diagnostic basicDiagnostic = null;
	    if( !resource.getErrors().isEmpty() || !resource.getWarnings().isEmpty() ) {
	      basicDiagnostic = new BasicDiagnostic( Diagnostic.ERROR,
	                                             Activator.PLUGIN_ID,
	                                             0,
	                                             String.format( Messages.getString( "ToscaEditor.CreateModelErrorMessage" ), //$NON-NLS-1$
	                                                            resource.getURI() ),
	                                             new Object[]{
	                                               exception == null
	                                                                ? ( Object )resource
	                                                                : exception
	                                             } );
	      ( ( BasicDiagnostic )basicDiagnostic ).merge( EcoreUtil.computeDiagnostic( resource,
	                                                                                 true ) );
	    } else if( exception != null ) {
	      basicDiagnostic = new BasicDiagnostic( Diagnostic.ERROR,
	                                             Activator.PLUGIN_ID,
	                                             0,
	                                             Messages.getString( "ToscaEditor.CreateModelErrorMessage" ), //$NON-NLS-1$
	                                             new Object[]{
	                                               exception
	                                             } );
	    } else {
	      basicDiagnostic = Diagnostic.OK_INSTANCE;
	    }
	    return basicDiagnostic;
	  }
	  
	  
	  protected void importDiagram( final ToscaModelLayer model ) {
	    final Diagram diagram = getDiagramTypeProvider().getDiagram();
	    diagram.setActive( true );
	    getEditingDomain().getCommandStack()
	      .execute( new RecordingCommand( getEditingDomain() ) {

	        @Override
	        protected void doExecute() {
	          if (model.getDocumentRoot() != null) {
	            DocumentRoot documentRoot = model.getDocumentRoot();
	            DefinitionsType definitionsType = documentRoot.getDefinitions();
	            EList<TServiceTemplate> serviceTemplates = definitionsType.getServiceTemplate();
	            EList<TNodeTypeImplementation> nodeTypesImplementation = definitionsType.getNodeTypeImplementation();
	            EList<TArtifactTemplate> artifactTemplates = definitionsType.getArtifactTemplate();        
	            
	            Boolean substitute = false;
	            ContainerShape containerShapeTST = null;
	            
	            for (TServiceTemplate tst : serviceTemplates) { 
	                
	              if ( tst.getSubstitutableNodeType() != null ){
	                //tst is a group component
	                TServiceTemplateExtension tstG = (TServiceTemplateExtension) tst;
	                addContainerElement (tst, containerShapeTST, tstG.getX(), tstG.getY(), tstG.getWidth(), tstG.getHeight());
	                substitute = true;
	              }
	              
	              else{
	                TServiceTemplateExtension tste = (TServiceTemplateExtension) tst;
	                addContainerElement (tst, diagram, 0, 0, tste.getWidth(), tste.getHeight());
	                containerShapeTST = ( ContainerShape )getDiagramTypeProvider().getFeatureProvider()
	                    .getPictogramElementForBusinessObject( tst );
	              }
	              
	              ContainerShape containerShape = ( ContainerShape )getDiagramTypeProvider().getFeatureProvider()
	                .getPictogramElementForBusinessObject( tst ); 
	              
	              TTopologyTemplate topology = tst.getTopologyTemplate();
	              
	              if (topology == null)
	                break;
	                           
	                for (TNodeTemplate tnt : topology.getNodeTemplate()) {

	                  if ( (tnt.getType()!=null) && (tnt.getType().toString().contains( "substituteNode" )) ) {//$NON-NLS-1$
	                    continue;
	                  }
	                  
	                  TNodeTemplateExtension tnte = (TNodeTemplateExtension) tnt;
	                  addContainerElement( tnt, containerShape, tnte.getX(), tnte.getY(), tnte.getWidth(), tnte.getHeight() );
	                  
	                  ContainerShape containerShapeTNT = ( ContainerShape )getDiagramTypeProvider().getFeatureProvider()
	                      .getPictogramElementForBusinessObject( tnt ); 
	                  
	                  //Add Deployment Artifacts
	                  if ( tnt.getDeploymentArtifacts() != null && tnt.getDeploymentArtifacts().getDeploymentArtifact() != null ){
	                      for (TDeploymentArtifact tda : tnt.getDeploymentArtifacts().getDeploymentArtifact() ){

	                                addContainerElement( tda, containerShapeTNT, 0, 0, 0, 0 );
	                          
	                      }
	                  }
	                  
	                  //Find NodeTypeImplementation
	                  TNodeTypeImplementation nodeTypeImplementation = null;
	                  for (TNodeTypeImplementation tempNodeImplementation : nodeTypesImplementation){
	                    if (tnt.getName().equals( tempNodeImplementation.getNodeType().toString())){
	                      nodeTypeImplementation = tempNodeImplementation;
	                      break;
	                    }
	                  }
	                  if (nodeTypeImplementation!=null && nodeTypeImplementation.getImplementationArtifacts()!=null){
	                    EList<ImplementationArtifactType> implementationArtifacts = nodeTypeImplementation.getImplementationArtifacts().getImplementationArtifact();
	                    for (ImplementationArtifactType tempImplementationArtifact : implementationArtifacts){
	                      if (tempImplementationArtifact.getOperationName().equals( "execute" ))
	                      {
	                        for (TArtifactTemplate tempArtifactTemplate : artifactTemplates){
	                          if (tempArtifactTemplate.getId().equals(tempImplementationArtifact.getArtifactRef().toString()))
	                            addContainerElement( tempArtifactTemplate, containerShapeTNT, 0, 0, 0, 0 );
	                        }
	                      }
	     
	                    }
	                  }
	 
	                }                
	                
	                if ( substitute ){
	                  //Composite Component Service Template
	                  //Add deployment artifacts to composite component's service template
	                  
	                  for (TServiceTemplate tempTst : serviceTemplates) { 
	                    for (TNodeTemplate tnt : tempTst.getTopologyTemplate().getNodeTemplate()) {
	  
	                          
	                          if ( tst.getSubstitutableNodeType() != null && (tnt.getType()!=null) && tnt.getType().toString().equals( tst.getSubstitutableNodeType().toString()) ){
	                            //Found the service template that substitutes the specific node template
	                            
	                            ContainerShape containerShapeTNT = ( ContainerShape )getDiagramTypeProvider().getFeatureProvider()
	                                .getPictogramElementForBusinessObject( tst ); 
	                            
	                            //Add Deployment Artifacts
	                            if ( tnt.getDeploymentArtifacts() != null && tnt.getDeploymentArtifacts().getDeploymentArtifact() != null ){
	                                for (TDeploymentArtifact tda : tnt.getDeploymentArtifacts().getDeploymentArtifact() ){

	                                          addContainerElement( tda, containerShapeTNT, 0, 0, 0, 0 );
	                                    
	                                }
	                            } 
	                            break;
	                          }
	                        
	                      
	                    }
	                  }
	                  substitute = false;
	                }
	                else{
	                  //Application Service Template
	                  //Add deployment artifacts to application's service template
	                  
	                }

	            }
	            
	            //Add Relationships
	            for (TServiceTemplate tst : serviceTemplates) { 
	              
	              if ( tst.getTopologyTemplate() == null )
	                continue;
	              
	              for (TRelationshipTemplate trt : tst.getTopologyTemplate().getRelationshipTemplate()) {    
	                  
	               SourceElementType se = trt.getSourceElement();
	               TargetElementType te = trt.getTargetElement();
	               String sourceID = se.getRef();
	               String targetID = te.getRef();
	               Anchor sourceAnchor = null, targetAnchor = null;
	               for (TServiceTemplate tstTemp : serviceTemplates) {
	                   for (TNodeTemplate tnt : tstTemp.getTopologyTemplate().getNodeTemplate()) {
	                     
	                       ContainerShape containerShapeTNT;
	                       
	                       if ( tnt.getId().equals(sourceID) ){
	                           if ( (tnt.getType()!=null) && (tnt.getType().toString().contains( "substituteNode" ) == true) ){
	                               containerShapeTNT = getAnchorContainer(model, tnt);
	                           }else{
	                               containerShapeTNT = ( ContainerShape )getDiagramTypeProvider().getFeatureProvider()
	                                       .getPictogramElementForBusinessObject( tnt ); 
	                           }
	                           if ( containerShapeTNT.getAnchors() != null ){
	                                for ( Anchor anchor : containerShapeTNT.getAnchors() ){
	                                    if (anchor instanceof ChopboxAnchor){
	                                        sourceAnchor = anchor;
	                                        break;
	                                    }
	                                }
	                           }
	                      
	                       } else if ( tnt.getId().equals(targetID) ){
	                           if ( ((tnt.getType()!=null)) && (tnt.getType().toString().contains( "substituteNode" ) == true) ){
	                               containerShapeTNT = getAnchorContainer(model, tnt);
	                           }else{
	                               containerShapeTNT = ( ContainerShape )getDiagramTypeProvider().getFeatureProvider()
	                                       .getPictogramElementForBusinessObject( tnt ); 
	                           }
	                           if ( containerShapeTNT.getAnchors() != null ){
	                                for ( Anchor anchor : containerShapeTNT.getAnchors() ){
	                                    if (anchor instanceof ChopboxAnchor){
	                                        targetAnchor = anchor;
	                                        break;
	                                    }
	                                }
	                           }
	                       }
	                   }
	               }
	       
	                
	               addRelationshipContainerElement( trt, sourceAnchor, targetAnchor );
	              }
	          }
	          }
	        }

	      } );
	  }
	  
	  
	  private ContainerShape getAnchorContainer(final ToscaModelLayer model, TNodeTemplate nodeTemplate){
	        // Find the substitute TServiceTemplate
	      TServiceTemplate substituteNode = null;

	        for (TServiceTemplate tempServiceTemplate : model.getDocumentRoot()
	          .getDefinitions()
	          .getServiceTemplate()){
	           
	          if (tempServiceTemplate.getSubstitutableNodeType() != null &&
	                  tempServiceTemplate.getId().equals(nodeTemplate.getId())) 
	          {
	            substituteNode = tempServiceTemplate;
	            break;
	          }
	        }
	        return ( ContainerShape )getDiagramTypeProvider().getFeatureProvider()
	                .getPictogramElementForBusinessObject( substituteNode ); 
	  }
	  
	  protected PictogramElement addContainerElement( final EObject element,
	                                                  final ContainerShape parent, int x_axis, int y_axis, int width, int height )
	  {
	    
	    final IFeatureProvider featureProvider = getDiagramTypeProvider().getFeatureProvider();
	    
	    AddContext context = new AddContext( new AreaContext(), element );
	    IAddFeature addFeature = featureProvider.getAddFeature( context );
	    context.setNewObject( element );    
	    context.setTargetContainer( parent );
	    context.setLocation(x_axis, y_axis);
	    context.setSize( width, height );
	    PictogramElement pictElement = null;
	    
	    boolean canAdd  = false;
	    if (addFeature != null) {
	      canAdd = addFeature.canAdd( context ) ;
	    }
	      
	    if( canAdd ) {
	      pictElement = addFeature.add( context );
	      
	      if (element instanceof TDeploymentArtifact && ((TDeploymentArtifact) element).getArtifactType().toString().compareTo( "MonitoringProbe" )==0){
	        //There is no pictogram element linked to the monitoring image
	        return pictElement;
	      }    
	      else{
	        featureProvider.link( pictElement, new Object[]{ element } );
	        return pictElement;
	      }
	    }
	    
	    return null;

	  }

	  protected PictogramElement addRelationshipContainerElement( final EObject element,
	          final Anchor sourceAnchor, final Anchor targetAnchor ){
	      
	      if (sourceAnchor == null)
	          return null;
	      
	      if (targetAnchor == null)
	          return null;
	      
	      AddConnectionContext context = new AddConnectionContext(sourceAnchor, targetAnchor);
	      context.setNewObject( element );
	      
	      final IFeatureProvider featureProvider = getDiagramTypeProvider().getFeatureProvider();
	      IAddFeature addFeature = featureProvider.getAddFeature( context );
	      
	        PictogramElement pictElement = null;
	        
	        boolean canAdd = addFeature.canAdd( context ) ;
	            
	        if( canAdd ) {
	          pictElement = addFeature.add( context );
	          featureProvider.link( pictElement, new Object[]{ element } );
	        }
	        
	        return pictElement;

	  }

	  
	  
	  @Override
	  public void createPartControl(Composite parent) {
	    super.createPartControl(parent);
	    // hides grid on diagram, but you can reenable it
	    if (getGraphicalViewer() != null && getGraphicalViewer().getEditPartRegistry() != null) {
	      ScalableFreeformRootEditPart rootEditPart = (ScalableFreeformRootEditPart) getGraphicalViewer().getEditPartRegistry().get(LayerManager.ID);
	      IFigure gridFigure = ((LayerManager) rootEditPart).getLayer(LayerConstants.GRID_LAYER);
	      gridFigure.setVisible(true);
	    }
	    // setPartName("MyDiagram2");
	  }

	//  @Override
	//  protected ContextMenuProvider createContextMenuProvider() {
//	    return new ActivitiEditorContextMenuProvider(getGraphicalViewer(), getActionRegistry(), getDiagramTypeProvider());
	//  }

	  public static GraphicalViewer getActiveGraphicalViewer() {
	    return gViewer;
	  }

	  @Override
	  public void dispose() {
	    super.dispose();

	    final ToscaDiagramEditorInput tdei = (ToscaDiagramEditorInput) getEditorInput();

	    ModelHandler.removeModel(EcoreUtil.getURI(getDiagramTypeProvider().getDiagram()));
	    ToscaDiagramCreator.dispose(tdei.getDiagramFile());
	  }
	  
	}