edl.apex

List<Case> cases = new List<Case>{
	new Case(Subject = 'Mild problem', Origin = 'Phone', Escalated__c = false, Status = 'Closed')
	, new Case(Subject = 'Problem 1', Origin = 'Web', Escalated__c = true, Status = 'Closed')
	, new Case(Subject = 'Problem 2', Origin = 'Web', Escalated__c = true, Status = 'In Progress')
	, new Case(Subject = 'Problem 3', Origin = 'Email', Escalated__c = true, Status = 'Open')
};

class MildCase extends CaseEntity {
	protected override Edl.Expression identityExpression() {
		return subject().isEqualTo('Mild problem');
	}
}

class NotClosedCases extends CaseEntity {
	protected override Edl.Expression identityExpression() {
		return status().isNoneOf(closedStatuses());
	}
}

class EscalatedCasesNotClosed extends CaseEntity {
	protected override Edl.Expression identityExpression() {
		return identitybBuilder();
	}
}

abstract class CaseEntity
		extends CaseRecord
		implements Edl.HasIdentity {

	public Edl.Expression identity() {
		if (identity == null) {
			identity = identityExpression();
		}
		return identity;
	}

	protected abstract Edl.Expression identityExpression();

	Edl.Expression identity;
}

virtual class CaseRecord extends Record {
	public StringField subject() {
		return stringFieldUsing(Case.Subject);
	}

	public StringField status() {
		return stringFieldUsing(Case.Status);
	}
}

abstract class Record {

	public Sobject sobject() {
		if (sobject != null) {
			return sobject;
		}
		if (this instanceof Edl.HasIdentity) {
			setSobject();
			return sobject;
		}
		throw new UnknownSobjectException();
	}

	protected StringField stringFieldUsing(SobjectField field) {
		PrimitiveDataField result = fields.get(field);
		
		if (result == null) {
			result = new StringField(this, field);
			fields.put(field, result);
		}

		return (StringField)result;
	}

	Map<SobjectField, RecordField> fields = new Map<SobjectField, RecordField>();

	void setSobject() {

	}

}


class StringField extends RecordField {
	public String value() {
		return asString();
	}

	public String setTo(String value) {
		setFieldValueT(value);
	}
}

abstract class RecordField {
	public RecordField(Record record, SobjectField field) {
		this.record = record;
		this.field = field;
		previousValue = nullableValue();
	}

	public Boolean hasValue() {
		Object fieldValue = nullableValue();
		if (fieldValue == null) {
			return false;
		}
		if (fieldValue instanceof String) {
			return String.isNotBlank(fieldValue);
		}
		return true;
	}

	public Boolean doesNotHaveValue() {
		return !hasValue();
	}

	public Boolean hasChanged() {
		return previousValue != nullableValue();
	}

	public Boolean doesNotHaveChanged() {
		return previousValue == nullableValue();
	}

	public void discardChange() {
		setFieldValueTo(previousValue);
	}

	public void remove() {
		setFieldValueTo(null);
	}


	public Boolean canBeAnInteger() {
		return canBeAnInteger(nullableValue());
	}

	protected Boolean canBeAnInteger(Object value) {
		Integer integerValue;
		try {
			integerValue = Integer.valueOf(value);
		} catch(TypeException e) {
			return false;
		}
		return integerValue != null;
	}

	public Boolean cannotBeAnInteger() {
		return !canBeAnInteger();
	}

	public Integer asInteger() {
		return Integer.valueOf(nonNullableValue());
	}

	public Boolean canBeAString() {
		return canBeAString(nullableValue());
	}

	protected Boolean canBeAString(Object value) {
		String stringValue;
		try {
			stringValue = String.valueOf(value);
		} catch(TypeException e) {
			return false;
		}
		return String.isNotBlank(stringValue);
	}

	public Boolean cannotBeAString() {
		return !canBeAString();
	}

	public String asString() {
		return String.valueOf(nonNullableValue());
	}


	protected setFieldValueTo(Object value) {
		record.sobject().put(field, value);
	}


	Record record;
	SobjectField field;
	Object previousValue;

	Object nullableValue() {
		return record.sobject().get(field);
	}

	Object nonNullableValue() {
		if (hasValue()) {
			return nullableValue();
		}
		throw newAccessToNullException();
	}
}





abstract class SobjectBasedEntity extends Entity {
	protected Edl.StringBasedExpressionBuilder stringExpressionFrom(SobjectField field) {
		return stringBasedExpressionBuilderFor(field);
	}
}

abstract class Entity

	public Entity() {
		setMid();
	}

	public EntitySpec spec() {
		if (spec == null) {
			spec = new EntitySpec(identity());
		}
		return spec;
	}

	protected Edl.StringBasedExpressionBuilder stringBasedExpressionBuilderFor(SobjectField field) {
		stringBasedExpressionBuilder.setPropertyTo(field);
		return stringBasedExpressionBuilder;
	}

	static Long lastMid = 0L;

	static Edl.StringBasedExpressionBuilder stringBasedExpressionBuilder {
		get {
			if (stringBasedExpressionBuilder == null) {
				stringBasedExpressionBuilder = new Edl.StringBasedExpressionBuilder();
			}
			return stringBasedExpressionBuilder;
		}
		set;
	}



	Long mid;
	EntitySpec spec;


	void setMid() {
		mid = lastMid + 1;
		lastMid = mid;
	}
}

class StringBasedExpressionBuilder extends ExpressionBuilder {
	

	EntitySpec isEqualTo(String stringValue) {

	}
}

class Edl {
	interface HasIdentity {
		Expression identity();
	}

	abstract class Expression
			implements hasIdentity {

		public Expression identity() {
			return this;
		}
	}

	abstract class TwoSidesExpression extends Expression {
		Object leftSide;
		Object rightSide;
	}

	class IsEqualToAnyOf extends TwoSidesExpression { }
}