package norm

import (
	"context"
	"database/sql"
	"fmt"
	"strings"
)

type delete_ struct {
	from  string
	where *Expr
}

func Delete() delete_ {
	return delete_{}
}

type DeleteOpt func(s *delete_)

func (s delete_) From(table string) delete_ {
	s.from = table
	return s
}

func (s delete_) Where(expr Expr) delete_ {
	s.where = &expr
	return s
}

func (s delete_) Compile() (string, []any, error) {
	var sql strings.Builder
	var args []any

	sql.WriteString("DELETE")

	if s.from == "" {
		return "", nil, fmt.Errorf("FROM clause is required")
	}
	sql.WriteString(" FROM ")
	sql.WriteString(s.from)

	if s.where != nil {
		sql.WriteString(" WHERE ")
		sql.WriteString(s.where.String())

		args = s.where.Binds()
	}

	return sql.String(), args, nil
}

func (s delete_) MustCompile() (string, []any) {
	sql, args, err := s.Compile()
	if err != nil {
		panic(err)
	}

	return sql, args
}

func (s delete_) Build(p Database) (*sql.Stmt, []any, error) { return Build(s, p) }
func (s delete_) MustBuild(p Database) (*sql.Stmt, []any)    { return MustBuild(s, p) }

func (s delete_) Exec(p Database) (sql.Result, error) { return Exec(s, p) }
func (s delete_) ExecContext(ctx context.Context, p Database) (sql.Result, error) {
	return ExecContext(ctx, s, p)
}
func (s delete_) MustExec(p Database) sql.Result { return MustExec(s, p) }
func (s delete_) MustExecContext(ctx context.Context, p Database) sql.Result {
	return MustExecContext(ctx, s, p)
}