package orm

import (
	"context"
	"database/sql"
)

type Selector[T any] struct {
	builder
	columns   []Selectable
	tableName string
	where     []Predicate
	groupBy   []Expression

	db *DB
}

func NewSelector[T any](db *DB) *Selector[T] {
	s := &Selector[T]{
		db: db,
		builder: builder{
			dialect: db.dialect,
			quoter:  db.quoter,
		},
	}
	return s

}

func (s *Selector[T]) Build() (*Query, error) {

	m, err := s.db.r.Get(new(T))
	if err != nil {
		return nil, err
	}

	s.m = m

	s.sb.WriteString("SELECT ")

	if err = s.buildColumns(s.columns); err != nil {
		return nil, err
	}

	s.sb.WriteString(" FROM ")

	/// tableName
	if len(s.tableName) == 0 {
		s.Quoter(s.m.TableName)
	} else {
		s.Quoter(s.tableName)
	}

	///where
	if len(s.where) > 0 {
		s.sb.WriteString(" WHERE ")

		if err = s.buildPredicate(s.where); err != nil {
			return nil, err
		}
	}

	/// GROUP BY
	if len(s.groupBy) > 0 {
		s.sb.WriteString(" GROUP BY ")

		if err = s.buildGroupBy(s.groupBy); err != nil {
			return nil, err
		}
	}

	s.sb.WriteString(";")

	return &Query{
		SQL:  s.sb.String(),
		Args: s.args,
	}, nil

}

func (s *Selector[T]) Get(ctx context.Context) (*T, error) {
	q, err := s.Build()
	if err != nil {
		return nil, err
	}

	var rows *sql.Rows
	if rows, err = s.db.db.QueryContext(ctx, q.SQL, q.Args...); err != nil {
		return nil, err
	}
	/// 确认有没有数据
	for !rows.Next() {
		return nil, ErrNoRows
	}
	result := new(T)

	valuer := s.db.creator(s.m, result)
	if err = valuer.SetColumn(rows); err != nil {
		return nil, err
	}

	return result, nil
}

//func (s *Selector[T]) Get(ctx context.Context) (*T, error) {
//	q, err := s.Build()
//	if err != nil {
//		return nil, err
//	}
//
//	var rows *sql.Rows
//	if rows, err = s.db.db.QueryContext(ctx, q.SQL, q.Args...); err != nil {
//		return nil, err
//	}
//	/// 确认有没有数据
//	for !rows.Next() {
//		return nil, ErrNoRows
//	}
//
//	result := new(T)
//
//	var (
//		cs []string
//	)
//	if cs, err = rows.Columns(); err != nil {
//		return nil, err
//	}
//
//	vals := make([]any, 0)
//	for _, e := range cs {
//		if f, ok := s.m.ColumnMap[e]; ok {
//			val := reflect.New(f.Typ)
//			vals = append(vals, val.Interface())
//		} else {
//			return nil, errs.NewErrUnknownColumn(e)
//		}
//	}
//	err = rows.Scan(vals...)
//	if err != nil {
//		return nil, errs.ErrScanErr
//	}
//
//	resultValue := reflect.ValueOf(result)
//	for i, c := range cs {
//		if f, ok := s.m.ColumnMap[c]; ok {
//			resultValue.Elem().FieldByName(f.GoName).Set(reflect.ValueOf(vals[i]).Elem())
//		}
//	}
//
//	return result, nil
//}

func (s *Selector[T]) GetMulti(ctx context.Context) ([]*T, error) {
	q, err := s.Build()
	if err != nil {
		return nil, err
	}

	var rows *sql.Rows
	if rows, err = s.db.db.QueryContext(ctx, q.SQL, q.Args...); err != nil {
		return nil, err
	}

	result := make([]*T, 0)

	for rows.Next() {
		m := new(T)
		valuer := s.db.creator(s.m, m)
		if err = valuer.SetColumn(rows); err != nil {
			return nil, err
		}
		result = append(result, m)
	}

	return result, nil
}