import (
	"database/sql"
	"database/sql/driver"
	"go/ast"
	"reflect"
)

// Expression expression interface
type Expression interface {
	Build(builder Builder)
}

// NegationExpressionBuilder negation expression builder
type NegationExpressionBuilder interface {
	NegationBuild(builder Builder)
}

// Expr raw expression
type Expr struct {
	SQL                string
	Vars               []interface{}

	column := "column-name"
	results := []struct {
		Expressions  []clause.Expression
		ExpectedVars []interface{}
		Result       string
	}{{
		Expressions: []clause.Expression{
			clause.Eq{Column: column, Value: "column-value"},
		},
		ExpectedVars: []interface{}{"column-value"},
		Result:       "`column-name` = ?",
	}, {
		Expressions: []clause.Expression{
			clause.Eq{Column: column, Value: nil},

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.apache.maven.project.tests</groupId>
  <artifactId>build-path-expression</artifactId>
  <version>1</version>
  <build>
    <sourceDirectory>sources</sourceDirectory>
    <resources>
      <resource>
        <directory>${project.build.sourceDirectory}</directory>
      </resource>
    </resources>
  </build>

    override fun isDefinitelyNull(expression: KtExpression): Boolean =
        getDefiniteNullability(expression) == DefiniteNullability.DEFINITELY_NULL

    override fun isDefinitelyNotNull(expression: KtExpression): Boolean =
        getDefiniteNullability(expression) == DefiniteNullability.DEFINITELY_NOT_NULL

    private fun getDefiniteNullability(expression: KtExpression): DefiniteNullability {

                false

            !is KtExpression ->
                errorWithAttachment("Unhandled Non-KtExpression parent of KtExpression: ${parent::class}") {
                    withPsiEntry("parent", parent)
                }
            /**
             * EXPRESSIONS
             */
            // Enum entries, type parameters, lamda expressions and script

    }

    override fun getExpectedType(expression: PsiElement): KtType? {
        val ktExpression = expression.getParentOfType<KtExpression>(false) ?: return null
        val parentExpression = if (ktExpression.parent is KtLabeledExpression) {
            // lambda -> labeled expression -> lambda argument (value argument)
            ktExpression.parent.parent
        } else {
            ktExpression.parent
        }

            type.isULong -> KtConstantValue.KtUnsignedLongConstantValue((value as Number).toLong().toULong(), expression)
            type.isString -> KtConstantValue.KtStringConstantValue(value.toString(), expression)
            type.isFloat -> KtConstantValue.KtFloatConstantValue((value as Number).toFloat(), expression)
            type.isDouble -> KtConstantValue.KtDoubleConstantValue((value as Number).toDouble(), expression)
            else -> null

    override fun evaluate(
        expression: KtExpression,
        mode: KtConstantEvaluationMode,
    ): KtConstantValue? {
        val bindingContext = analysisContext.analyze(expression)

        val constant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, bindingContext)
        if (mode == KtConstantEvaluationMode.CONSTANT_EXPRESSION_EVALUATION) {

    }

    private val KtExpression.isImplicitSmartCastInfoTarget: Boolean
        get() = this is KtNameReferenceExpression || this is KtOperationReferenceExpression

    private fun getMatchingFirQualifiedAccessExpression(expression: KtExpression): FirQualifiedAccessExpression? {
        if (!expression.isImplicitSmartCastInfoTarget) return null

        get() = analysisSession.token

    override fun getSmartCastedInfo(expression: KtExpression): KtSmartCastInfo? {
        val bindingContext = analysisContext.analyze(expression)
        val stableSmartCasts = bindingContext[BindingContext.SMARTCAST, expression]
        val unstableSmartCasts = bindingContext[BindingContext.UNSTABLE_SMARTCAST, expression]

        return when {
            stableSmartCasts != null -> {