package net.shadowfacts.kiwidsl

import no.birkett.kiwi.*

/**
 * @author shadowfacts
 */
class KiwiContext(val solver: Solver) {
	val REQUIRED = Strength.REQUIRED
	val STRONG = Strength.STRONG
	val MEDIUM = Strength.MEDIUM
	val WEAK = Strength.WEAK

	// Constraints
	infix fun ExpressionConvertible.equalTo(other: ExpressionConvertible): Constraint {
		return Symbolics.equals(this.toExpression(), other.toExpression()).apply(solver::addConstraint)
	}

	fun ExpressionConvertible.equalTo(other: ExpressionConvertible, strength: Double): Constraint {
		return Symbolics.equals(this.toExpression(), other.toExpression()).setStrength(strength).apply(solver::addConstraint)
	}

	infix fun ExpressionConvertible.equalTo(constant: Number): Constraint {
		return Symbolics.equals(this.toExpression(), constant.toDouble()).apply(solver::addConstraint)
	}

	fun ExpressionConvertible.equalTo(constant: Number, strength: Double): Constraint {
		return Symbolics.equals(this.toExpression(), constant.toDouble()).setStrength(strength).apply(solver::addConstraint)
	}

	infix fun ExpressionConvertible.lessThanOrEqualTo(other: ExpressionConvertible): Constraint {
		return Symbolics.lessThanOrEqualTo(this.toExpression(), other.toExpression()).apply(solver::addConstraint)
	}

	fun ExpressionConvertible.lessThanOrEqualTo(other: ExpressionConvertible, strength: Double): Constraint {
		return Symbolics.lessThanOrEqualTo(this.toExpression(), other.toExpression()).setStrength(strength).apply(solver::addConstraint)
	}

	infix fun ExpressionConvertible.lessThanOrEqualTo(constant: Number): Constraint {
		return Symbolics.lessThanOrEqualTo(this.toExpression(), constant.toDouble()).apply(solver::addConstraint)
	}

	fun ExpressionConvertible.lessThanOrEqualTo(constant: Number, strength: Double): Constraint {
		return Symbolics.lessThanOrEqualTo(this.toExpression(), constant.toDouble()).setStrength(strength).apply(solver::addConstraint)
	}

	infix fun ExpressionConvertible.greaterThanOrEqualTo(other: ExpressionConvertible): Constraint {
		return Symbolics.greaterThanOrEqualTo(this.toExpression(), other.toExpression()).apply(solver::addConstraint)
	}

	fun ExpressionConvertible.greaterThanOrEqualTo(other: ExpressionConvertible, strength: Double): Constraint {
		return Symbolics.greaterThanOrEqualTo(this.toExpression(), other.toExpression()).setStrength(strength).apply(solver::addConstraint)
	}

	infix fun ExpressionConvertible.greaterThanOrEqualTo(constant: Number): Constraint {
		return Symbolics.greaterThanOrEqualTo(this.toExpression(), constant.toDouble()).apply(solver::addConstraint)
	}

	fun ExpressionConvertible.greaterThanOrEqualTo(constant: Number, strength: Double): Constraint {
		return Symbolics.greaterThanOrEqualTo(this.toExpression(), constant.toDouble()).setStrength(strength).apply(solver::addConstraint)
	}

	// Addition
	operator fun ExpressionConvertible.plus(other: ExpressionConvertible): Expression {
		return Symbolics.add(this.toExpression(), other.toExpression())
	}

	operator fun ExpressionConvertible.plus(constant: Number): Expression {
		return Symbolics.add(this.toExpression(), constant.toDouble())
	}

	// Subtraction
	operator fun ExpressionConvertible.minus(other: ExpressionConvertible): Expression {
		return Symbolics.subtract(this.toExpression(), other.toExpression())
	}

	operator fun ExpressionConvertible.minus(constant: Number): Expression {
		return Symbolics.subtract(this.toExpression(), constant.toDouble())
	}

	// Multiplication
	operator fun ExpressionConvertible.times(other: ExpressionConvertible): Expression {
		return Symbolics.multiply(this.toExpression(), other.toExpression())
	}

	operator fun ExpressionConvertible.times(constant: Number): Expression {
		return Symbolics.multiply(this.toExpression(), constant.toDouble())
	}

	// Division
	operator fun ExpressionConvertible.div(other: ExpressionConvertible): Expression {
		return Symbolics.divide(this.toExpression(), other.toExpression())
	}

	operator fun ExpressionConvertible.div(constant: Number): Expression {
		return Symbolics.divide(this.toExpression(), constant.toDouble())
	}
}

fun Solver.dsl(init: KiwiContext.() -> Unit): Solver {
	KiwiContext(this).init()
	return this
}