package hu.bme.mit.inf.dslreasoner.domains.cps.queries

import "http://www.eclipse.org/emf/2002/Ecore"
import "http://www.example.org/cps"

@QueryBasedFeature(feature = "applications")
pattern cpsApplications(Cps : CyberPhysicalSystem, AppInstance : ApplicationInstance) {
	CyberPhysicalSystem.applicationTypes.instances(Cps, AppInstance);
}

@QueryBasedFeature(feature = "hosts")
pattern cpsHosts(Cps : CyberPhysicalSystem, HostInstance : HostInstance) {
	CyberPhysicalSystem.hostTypes.instances(Cps, HostInstance);
}

@QueryBasedFeature(feature = "totalMemory")
pattern totalMemory(Host : HostInstance, Memory : EInt) {
	HostInstance.type.defaultMemory(Host, Memory);
}

@QueryBasedFeature(feature = "totalHdd")
pattern totalHdd(Host : HostInstance, Hdd : EInt) {
	HostInstance.type.defaultHdd(Host, Hdd);
}

@QueryBasedFeature(feature = "availableMemory")
pattern availableMemory(Host : HostInstance, Memory : java Integer) {
	find totalMemory(Host, TotalMemory);
	RequiredMemory == sum find memoryRequirement(Host, _, #_);
	Memory == eval(TotalMemory - RequiredMemory);
}

private pattern memoryRequirement(Host : HostInstance, App : ApplicationInstance, Memory : EInt) {
	find resourceRequirement(Host, App, Req);
	ResourceRequirement.requiredMemory(Req, Memory);
}

@QueryBasedFeature(feature = "availableHdd")
pattern availableHdd(Host : HostInstance, Hdd : java Integer) {
	find totalHdd(Host, TotalHdd);
	RequiredHdd == sum find hddRequirement(Host, _, #_);
	Hdd == eval(TotalHdd - RequiredHdd);
}

private pattern hddRequirement(Host : HostInstance, App : ApplicationInstance, Hdd : EInt) {
	find resourceRequirement(Host, App, Req);
	ResourceRequirement.requiredHdd(Req, Hdd);
}

private pattern resourceRequirement(Host : HostInstance, App : ApplicationInstance, Req : ResourceRequirement) {
	ApplicationInstance.allocatedTo(App, Host);
	ApplicationInstance.type.requirements(App, Req);
	HostInstance.type(Host, HostType);
	ResourceRequirement.hostType(Req, HostType);
}

@Constraint(severity = "error", key = {Host, App},
	message = "Application instance must be allocated to a supported host type.")
pattern allocationWithoutResourceRequirement(Host : HostInstance, App : ApplicationInstance) {
	ApplicationInstance.allocatedTo(App, Host);
	neg find resourceRequirement(Host, App, _);
}

@Constraint(severity = "error", key = {Host},
	message = "Insufficient memory available on host.")
pattern notEnoughAvailableMemory(Host : HostInstance) {
	find availableMemory(Host, Memory);
	check(Memory < 0);
}

@Constraint(severity = "error", key = {Host},
	message = "Insufficient HDD available on host.")
pattern notEnoughAvailableHdd(Host : HostInstance) {
	find availableHdd(Host, Hdd);
	check(Hdd < 0);
}

@Constraint(severity = "error", key = {Req, App},
	message = "Requirement must be satisfied by the required application type.")
pattern instanceDoesNotSatisfyRequirement(Req : Requirement, App : ApplicationInstance) {
	Requirement.instances(Req, App);
	neg find satisfyingInstance(Req, App);
}

private pattern satisfyingInstance(Req : Requirement, App : ApplicationInstance) {
	Requirement.instances(Req, App);
	Requirement.type(Req, Type);
	ApplicationInstance.type(App, Type);
}

@Constraint(severity = "error", key = {Req},
	message = "Requirement is not satisfied by enough application instances.")
pattern requirementNotSatisfied(Req : Requirement) {
	Instances == count find satisfyingInstance(Req, _);
	Requirement.count(Req, RequiredCount);
	check(Instances < RequiredCount);
}

@Constraint(severity = "error", key = {Req},
	message = "Redundant instances must not be allocated to the same host.")
pattern redundantInstancesOnSameHost(Req : Requirement) {
	Requirement.instances(Req, App1);
	Requirement.instances(Req, App2);
	App1 != App2;
	ApplicationInstance.allocatedTo(App1, Host);
	ApplicationInstance.allocatedTo(App2, Host);
}

pattern averageFreeMemoryMetric(Average : java Double) {
	Average == avg find freeMemoryPercentage(_, #_);
}

private pattern freeMemoryPercentage(Host : HostInstance, Free : java Double) {
	find totalMemory(Host, Total);
	find availableMemory(Host, Available);
	Free == eval((Available as double) / Total);
}

pattern averageFreeHddMetric(Average : java Double) {
	Average == avg find freeHddPercentage(_, #_);
}

private pattern freeHddPercentage(Host : HostInstance, Free : java Double) {
	find totalHdd(Host, Total);
	find availableHdd(Host, Available);
	Free == eval((Available as double) / Total);
}

pattern costMetric(Cost : java Integer) {
	Cost == sum find cpsCost(_, #_);
}

pattern cpsCost(Cps : CyberPhysicalSystem, Cost : java Integer) {
	AppCount == count find cpsApplications(Cps, _);
	HostCost == sum find hostInstanceCost(Cps, _, #_);
	Cost == eval(5 * AppCount + HostCost);
}

private pattern hostInstanceCost(Cps : CyberPhysicalSystem, Host : HostInstance, Cost : EInt) {
	find cpsHosts(Cps, Host);
	HostInstance.type.cost(Host, Cost);
}