import cloudConf.metamodels.cloudModel;

@incremental
machine cloudConf
{
	asmfunction model/0 {() = cloudConf.models.test.conf;}
	
	@state('name'='nodes','kind'='count-type','key'='NodeType','value'='Node')
	pattern nodes(Node,NodeType) = {
		cloudCompNode(Node);
		entity(NodeType) in cloudConf.metamodels.cloudModel;
        typeOf(NodeType,Node);
        
        neg pattern hasSubType(NodeType) = {
        	entity(NodeType);
        	entity(SubType);
        	subtypeOf(SubType,NodeType);
        }
	}
	
	pattern nodeOnHost(Node,Host) = {
		cloudCompNode(Node);
        cloudCompNode(Host);
        cloudCompNode.onRelation(R,Node,Host);
	}
	
	@state('name'='onRel','kind'='count-relation-by-type', 'key'='ToType', 'value'='To')
	pattern nodesOnHostWithType(ToType,From,To) = {
		find nodeOnHost(From,To);
		find nodes(To,ToType);
	}

		
	@goal('fixnumber' = '1')
	//@globalconstraint('upperbound' = '1')
    pattern appsInCloud(A) = {
		appNode(A);
	}
	
	//@goal('fixnumber' = '2')
	//@globalconstraint('upperbound' = '1')
	pattern dbsInCloud(DB) = {
	    dbNode(DB);
	}
	
	@goal('fixnumber' = '1')
    //@globalconstraint('upperbound' = '1')
	pattern storageInCloud(S) = {
        storageNode(S);
    }
     
    pattern cloudNode(Cloud) = {
    	cloudNode(Cloud);
    }
    
    /*@globalconstraint
    pattern limitedUnusedNodes() = {
    	find unusedNode(Node) # N;
    	check(N > 10);
    }*/
    
    /*@globalconstraint
    pattern limitedNodesOnCloud() = {
        find cloudCompNode(Node) # N;
        check(N > 20);
    }*/
    
    pattern cloudCompNode(Node) = {
    	cloudCompNode(Node);
    }
   
	
	@labelingliteral('priority' = '9')
	gtrule addCloudNode(out Cloud) = {
		precondition pattern cloud(CM) = {
			cloudConf.metamodels.cloudModel(CM);
		}
		
		action {
			new(cloudNode(Cloud) in model());
			rename(Cloud,"C");
		}
		
	}
	
	@labelingliteral('priority' = '7')
	gtrule addServerToSocket(inout Socket, out Server) = {
		precondition pattern socketNode(Socket) = {
			serversocketNode(Socket);
			neg find fullCluster(Socket);
		}
		
		action {
			new(serverNode(Server) in model());
			rename(Server,"S"+name(Socket));
			let R = undef in new(cloudCompNode.onRelation(R,Server,Socket));
		}
	}
	
	@labelingliteral('priority' = '7')
	gtrule addClusterToCloud(inout Cloud, out Cluster) = {
		precondition pattern cloudNode(Cloud) = {
			cloudNode(Cloud);
		}
		
		action {
			new(clusterNode(Cluster) in model());
			rename(Cluster,"Cl"+name(Cloud));
			let R = undef in new(cloudCompNode.onRelation(R,Cluster,Cloud));
		}
	}
	
	pattern fullCluster(Cluster) = {
		serverNode(S1);
		serverNode(S2);
		clusterNode(Cluster);
		find nodeOnHost(S1,Cluster);
		find nodeOnHost(S2,Cluster);
	}
	
	/*@labelingliteral
	gtrule addServerToCluster(inout Cluster, out Server) = {
		precondition pattern clusterNode(Cluster) = {
			clusterNode(Cluster);
			neg find fullCluster(Cluster);
		}
		
		action {
			new(serverNode(Server) in model());
			rename(Server,"S"+name(Cluster));
			let R = undef in new(cloudCompNode.onRelation(R,Server,Cluster));
		}
	}*/
	
	
	@labelingliteral('priority' = '5')
	gtrule addDBToServer(inout Server1, inout Server2, out DB) = {
		precondition pattern serverNodes(Server1, Server2) = {
			serverNode(Server1);
			serverNode(Server2);
			find nodeOnHost(Server1,Host);
			find nodeOnHost(Server2,Host);
			neg find busyServer(Server1);
			neg find busyServer(Server2);
		}
		
		action {
			new(dbNode(DB) in model());
			rename(DB,"D"+name(Server1)+name(Server2));
			let R = undef in seq{
				new(cloudCompNode.onRelation(R,DB,Server1));
				new(cloudCompNode.onRelation(R,DB,Server2));
			}
		}
	}
	
	pattern busyServer(Server) = {
		serverNode(Server);
		cloudCompNode(S);
		find nodeOnHost(S,Server);
	}
	
	pattern serversOnCluster(Server1,Server2) = {
		serverNode(Server1);
		serverNode(Server2);
		clusterNode(Cluster);
		find nodeOnHost(Server1,Cluster);
		find nodeOnHost(Server2,Cluster);
	}
	
	//@incremental
	pattern idleServerNodes(Server1, Server2) = {
		serverNode(Server1);
		serverNode(Server2);
		find serversOnCluster(Server1,Server2);
		neg find busyServer(Server1);
		neg find busyServer(Server2);
	}
	
	@labelingliteral('priority' = '5')
	gtrule addStorageToServer(inout Server1, inout Server2, out Storage) = {
		precondition find idleServerNodes(Server1, Server2)
		 //pattern serverNodes(Server1, Server2) = {
			//serverNode(Server1);
			//serverNode(Server2);
			//find serversOnCluster(Server1,Server2);
			//neg find busyServer(Server1);
			//neg find busyServer(Server2);
		//}
		
		action {
			new(storageNode(Storage) in model());
			rename(Storage,"St"+name(Server1)+name(Server2));
			let R = undef in seq{
				new(cloudCompNode.onRelation(R,Storage,Server1));
				new(cloudCompNode.onRelation(R,Storage,Server2));
			}
		}
	}
	
	pattern busyDB(DB) = {
		dbNode(DB);
		appNode(A);
		find nodeOnHost(A,DB);
	}
	
	@labelingliteral('priority' = '3')
	gtrule addAppToDB(inout DB1, inout DB2, out App) = {
		precondition pattern serverNodes(DB1, DB2) = {
			dbNode(DB1);
			dbNode(DB2);
			neg find busyDB(DB1);
			neg find busyDB(DB2);
		}
		
		action {
			new(appNode(App) in model());
			rename(App,"A"+name(DB1)+name(DB2));
			let R = undef in seq{
				new(cloudCompNode.onRelation(R,App,DB1));
				new(cloudCompNode.onRelation(R,App,DB2));
			}
		}
	}
	   
    @globalconstraint // nomatching
    pattern nonClusteredDB(DB) = {
        dbNode(DB);
        serverNode(Server1);
        serverNode(Server2);
        find nodeOnHost(DB,Server1);
        find nodeOnHost(DB,Server2);
        neg find serversOnCluster(Server1,Server2);
    }
	@globalconstraint('upperbound' = '10')
	pattern unusedNode(Node) = {
		cloudCompNode(Node);
		neg find nodeOnHost(OnNode,Node);
	}
	
	@state('name'='depends','kind'='count-relation', 'key'='App1', 'value'='App2')
    @state('name'='depends-Inverse','kind'='count-relation', 'order'='depends', 'key'='App2', 'value'='App1')
	pattern dependantAppNodes(App1, App2) = {
		appNode(App1);
		appNode(App2);
		appNode.depends(R,App1,App2);
	}
	
	@labelingliteral('priority' = '2')
	gtrule addAppDependency(inout App1, inout App2) = {
	   precondition find notDependantAppNodes(App1, App2)
	   
	   action {
	       let R = undef in 
	          new(appNode.depends(R,App1,App2));
	   }
	}
	
	pattern notDependantAppNodes(App1, App2) = {
       appNode(App1);
       appNode(App2);
       neg find dependantAppNodes(App1,App2);
    }
   
    //@goal // nomatching
    pattern notDependantApp(App) = {
    	find notDependantAppNodes(App,App2);
    } or {
    	find notDependantAppNodes(App1,App); 
    }
	
	@Incremental(reinterpret=transitiveClosure, ofPattern=dependantAppNodes)
	pattern transitiveDependency(App1,App2) = {}
	//	find dependantAppNodes(App1,App2);
	//} or {
	//	find dependantAppNodes(App1,App);
	//	find transitiveDependency(App,App2);
	//}
	
	//@globalconstraint // nomatching
	pattern cyclicDependency(App) = {
		appNode(App);
		find transitiveDependency(App,App);
	}
}