// The distsql Expression uses the placeholder syntax (@1, @2, @3..) to
// refer to columns. We format the expression using an IndexedVar formatting
// interceptor. A columnMap can optionally be used to remap the indices.
func distSQLExpression(expr parser.TypedExpr, columnMap []int) distsql.Expression {
	if expr == nil {
		return distsql.Expression{}
	}
	var f parser.FmtFlags
	if columnMap == nil {
		f = parser.FmtIndexedVarFormat(
			func(buf *bytes.Buffer, _ parser.FmtFlags, _ parser.IndexedVarContainer, idx int) {
				fmt.Fprintf(buf, "@%d", idx+1)
			},
		)
	} else {
		f = parser.FmtIndexedVarFormat(
			func(buf *bytes.Buffer, _ parser.FmtFlags, _ parser.IndexedVarContainer, idx int) {
				remappedIdx := columnMap[idx]
				if remappedIdx < 0 {
					panic(fmt.Sprintf("unmapped index %d", idx))
				}
				fmt.Fprintf(buf, "@%d", remappedIdx+1)
			},
		)
	}
	var buf bytes.Buffer
	expr.Format(&buf, f)
	return distsql.Expression{Expr: buf.String()}
}

func checkEquivExpr(a, b parser.TypedExpr, sel *selectNode) error {
	// The expressions above only use the values 1 and 2. Verify that the
	// simplified expressions evaluate to the same value as the original
	// expression for interesting values.
	for _, v := range []parser.Datum{
		parser.NewDInt(0),
		parser.NewDInt(1),
		parser.NewDInt(2),
		parser.NewDInt(3),
		parser.DNull,
	} {
		for i := range sel.curSourceRow {
			sel.curSourceRow[i] = v
		}
		ctx := &parser.EvalContext{}
		da, err := a.Eval(ctx)
		if err != nil {
			return fmt.Errorf("%s: %v", a, err)
		}
		db, err := b.Eval(ctx)
		if err != nil {
			return fmt.Errorf("%s: %v", b, err)
		}
		// This is tricky: we don't require the expressions to produce identical
		// results, but to either both return true or both return not true (either
		// false or NULL).
		if (da == parser.DBoolTrue) != (db == parser.DBoolTrue) {
			return fmt.Errorf("%s: %s: expected %s, but found %s", a, v, da, db)
		}
	}
	return nil
}

// RunFilter runs a filter expression and returns whether the filter passes.
func RunFilter(filter parser.TypedExpr, evalCtx *parser.EvalContext) (bool, error) {
	if filter == nil {
		return true, nil
	}

	d, err := filter.Eval(evalCtx)
	if err != nil {
		return false, err
	}

	return d != parser.DNull && bool(*d.(*parser.DBool)), nil
}

// The distsqlrun Expression uses the placeholder syntax (@1, @2, @3..) to
// refer to columns. We format the expression using the IndexedVar and StarDatum
// formatting interceptors. A columnMap can optionally be used to remap the
// indices.
func distSQLExpression(expr parser.TypedExpr, columnMap []int) distsqlrun.Expression {
	if expr == nil {
		return distsqlrun.Expression{}
	}

	// TODO(irfansharif): currently there’s no nice way to “compose” FmtFlags
	// out of multiple FmtFlag‘s (this unit does not exist today).
	// By introducing such composability, the flags below can be constructed
	// once and reused for subsequent calls. Additionally the construction of
	// the flags would not need to inspect expression type.
	var f parser.FmtFlags
	switch expr.(type) {
	case *parser.StarDatum:
		// By default parser.StarDatum is rendered as a DInt(0), but formatting
		// this as 0 we can replicate this behavior in distsqlrun.
		f = parser.FmtStarDatumFormat(
			func(buf *bytes.Buffer, _ parser.FmtFlags) {
				fmt.Fprintf(buf, "0")
			},
		)
	default:
		if columnMap == nil {
			f = parser.FmtIndexedVarFormat(
				func(buf *bytes.Buffer, _ parser.FmtFlags, _ parser.IndexedVarContainer, idx int) {
					fmt.Fprintf(buf, "@%d", idx+1)
				},
			)
		} else {
			f = parser.FmtIndexedVarFormat(
				func(buf *bytes.Buffer, _ parser.FmtFlags, _ parser.IndexedVarContainer, idx int) {
					remappedIdx := columnMap[idx]
					if remappedIdx < 0 {
						panic(fmt.Sprintf("unmapped index %d", idx))
					}
					fmt.Fprintf(buf, "@%d", remappedIdx+1)
				},
			)
		}
	}
	var buf bytes.Buffer
	expr.Format(&buf, f)
	return distsqlrun.Expression{Expr: buf.String()}
}