package option

const (
	TypeMaxColumn = iota
	TypeFullSql
	TypeSqlColumnConvert
	TypeSubQuery
	TypeQuery
	TypeNameKey //子查询
)

type Option interface {
	String() string
	Type() int
	Value() interface{}
}

func Filter(filter func(opt Option) bool, opts ...Option) {
	for i := range opts {
		if filter(opts[i]) {
			return
		}
	}
}

func Exist(ty int, opts ...Option) (Option, bool) {
	for i := range opts {
		if opts[i].Type() == ty {
			return opts[i], true
		}
	}
	return nil, false
}

type Query struct {
	Q map[string]interface{}
}

func WithQuery() Option {
	return &Query{Q: map[string]interface{}{}}
}

func (t Query) String() string {
	return "query"
}
func (t Query) Type() int          { return TypeQuery }
func (t Query) Value() interface{} { return t }

func QueryExist(opts ...Option) *Query {
	if r, ok := Exist(TypeQuery, opts...); ok {
		return r.Value().(*Query)
	}
	return nil
}

type QueryFunc func(q *Query)

func (f QueryFunc) Apply(q *Query) {
	f(q)
}

type MaxColumn int

func WithMaxColumn(c int) Option {
	return MaxColumn(c)
}

func (t MaxColumn) String() string {
	return "max:column"
}
func (t MaxColumn) Type() int          { return TypeMaxColumn }
func (t MaxColumn) Value() interface{} { return t }

func MaxColumnExist(opts ...Option) int {
	if r, ok := Exist(TypeMaxColumn, opts...); ok {
		return int(r.Value().(MaxColumn))
	}
	return 6
}

type FullSql bool

func WithFullSQL() Option {
	return FullSql(true)
}

func (t FullSql) String() string {
	return "full:sql"
}
func (t FullSql) Type() int          { return TypeFullSql }
func (t FullSql) Value() interface{} { return t }

func FullSqlExist(opts ...Option) bool {
	if r, ok := Exist(TypeFullSql, opts...); ok {
		return bool(r.Value().(FullSql))
	}
	return false
}

type SqlColumnConvertFunc func(col string) string

func SqlColumnConvert(f func(col string) string) Option {
	return SqlColumnConvertFunc(f)
}

func (t SqlColumnConvertFunc) String() string {
	return "sql:column:convert"
}
func (t SqlColumnConvertFunc) Type() int          { return TypeSqlColumnConvert }
func (t SqlColumnConvertFunc) Value() interface{} { return t }

func SqlColumnConvertExist(opts ...Option) SqlColumnConvertFunc {
	if r, ok := Exist(TypeSqlColumnConvert, opts...); ok {
		return r.Value().(SqlColumnConvertFunc)
	}
	return nil
}

type SubQuerySql struct {
	As string
}

func WithSubQuerySQL(as string) Option {
	return SubQuerySql{As: as}
}

func (t SubQuerySql) String() string {
	return "subquery:sql"
}
func (t SubQuerySql) Type() int          { return TypeSubQuery }
func (t SubQuerySql) Value() interface{} { return t }

func SubQueryExist(opts ...Option) (string, bool) {
	if r, ok := Exist(TypeSubQuery, opts...); ok {
		return r.Value().(SubQuerySql).As, true
	}
	return "", false
}

type NameKey string

func WithNameKey(name string) Option {
	return NameKey(name)
}

func (t NameKey) String() string {
	return "db.name.key"
}
func (t NameKey) Type() int          { return TypeNameKey }
func (t NameKey) Value() interface{} { return t }

func NameKeyExist(opts ...Option) (string, bool) {
	if r, ok := Exist(TypeNameKey, opts...); ok {
		return string(r.Value().(NameKey)), true
	}
	return "", false
}