import (
	"database/sql"
	"fmt"
	"log"
	"reflect"
)

type appendScanner struct {
	elemZero reflect.Value
	scan     func(target reflect.Value, v interface{}) error
	slice    reflect.Value
}

func (as *appendScanner) Scan(v interface{}) error {
	newTarget := reflect.Append(as.slice.Elem(), as.elemZero)
	newElem := newTarget.Index(newTarget.Len() - 1).Addr()
	if err := as.scan(newElem.Elem(), v); err != nil {
		return err
	}
	as.slice.Elem().Set(newTarget)
	return nil
}

// AppendScanner returns an sql.Scanner that appends the value from the database to the slice.
func AppendScanner(slice interface{}) sql.Scanner {
	t := reflect.TypeOf(slice)
	if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Slice || reflect.ValueOf(slice).IsNil() {
		log.Println(t.Kind())
		log.Println(t.Elem().Kind())
		panic("target should be a pointer to a slice variable")
	}
	elemType := t.Elem().Elem()
	var scan func(target reflect.Value, v interface{}) error
	if reflect.PtrTo(elemType).Implements(scannerType) || reflect.PtrTo(reflect.PtrTo(elemType)).Implements(scannerType) {
		scan = func(target reflect.Value, v interface{}) error {
			return target.Interface().(sql.Scanner).Scan(v)
		}
	} else {
		switch reflect.Zero(elemType).Interface().(type) {
		case int, *int, int64, *int64, int32, *int32:
			scan = func(target reflect.Value, v interface{}) error {
				target.SetInt(v.(int64))
				return nil
			}
		case uint, *uint, uint64, *uint64, uint32, *uint32:
			scan = func(target reflect.Value, v interface{}) error {
				target.SetUint(uint64(v.(int64)))
				return nil
			}
		case string, *string:
			scan = func(target reflect.Value, v interface{}) error {
				switch v := v.(type) {
				case string:
					target.SetString(v)
				case []byte:
					target.SetString(string(v))
				default:
					return fmt.Errorf("unexpected type %T to scan into %s", v, target.Type())
				}
				return nil
			}
		case []byte:
			scan = func(target reflect.Value, v interface{}) error {
				target.SetBytes(v.([]byte))
				return nil
			}
		default:
			// TODO add support for any driver.Value type
			panic("slice elements must implement sql.Scanner")
		}
	}
	// If pointer, wrap the scan to allocate the target value if not NULL
	if reflect.Zero(elemType).Kind() == reflect.Ptr {
		innerScan := scan
		scan = func(target reflect.Value, v interface{}) error {
			if v == nil {
				return nil
			}
			vv := reflect.New(target.Type().Elem())
			if err := innerScan(vv.Elem(), v); err != nil {
				return err
			}
			target.Set(vv)
			return nil
		}
	}
	return &appendScanner{
		elemZero: reflect.Zero(elemType),
		// isElemPtr: elemType.Kind() == reflect.Ptr,
		scan:  scan,
		slice: reflect.ValueOf(slice),
	}
}

func ExampleAppendScanner() {
	ctx := context.Background()
	db, err := sql.Open("sqlite3", ":memory:")
	if err != nil {
		log.Printf("Open: %v", err)
		return
	}
	defer db.Close()

	// Use AppendScanner to scan multiple columns values into a slice
	var v1 []int64
	appender := sqlutil.AppendScanner(&v1)
	if err := db.QueryRowContext(ctx, `SELECT 1, 2, 3`).
		Scan(appender, appender, appender); err != nil {
		log.Fatal(err)
	}
	fmt.Println(v1)

	// Use AppendScanner to scan value from multiple into a slice
	var v2 []string
	appender = sqlutil.AppendScanner(&v2)
	rows, err := db.QueryContext(ctx, ``+
		`   SELECT 'a'`+
		` UNION ALL`+
		`   SELECT 'b'`+
		` UNION ALL`+
		`   SELECT 'c'`,
	)
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next() {
		if err = rows.Scan(appender); err != nil {
			log.Fatal(err)
		}
	}
	if err = rows.Err(); err != nil {
		log.Fatal(err)
	}
	fmt.Println(v2)

	// Output:
	// [1 2 3]
	// [a b c]
}