// Copyright 2014 The ql Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ql

import (
	"bytes"
	"fmt"
	"go/ast"
	"reflect"
	"strings"
	"sync"
)

var (
	schemaCache = map[reflect.Type]*StructInfo{}
	schemaMu    sync.RWMutex
)

// StructInfo describes a struct type. An instance of StructInfo obtained from
// StructSchema is shared and must not be mutated.  That includes the values
// pointed to by the elements of Fields and Indices.
type StructInfo struct {
	Fields  []*StructField // Fields describe the considered fields of a struct type.
	HasID   bool           // Whether the struct has a considered field named ID of type int64.
	Indices []*StructIndex // Indices describe indices defined by the index or uindex ql tags.
	IsPtr   bool           // Whether the StructInfo was derived from a pointer to a struct.
}

// StructIndex describes an index defined by the ql tag index or uindex.
type StructIndex struct {
	ColumnName string // Name of the column the index is on.
	Name       string // Name of the index.
	Unique     bool   // Whether the index is unique.
}

// StructField describes a considered field of a struct type.
type StructField struct {
	Index         int               // Index is the index of the field for reflect.Value.Field.
	IsID          bool              // Whether the field corresponds to record id().
	IsPtr         bool              // Whether the field is a pointer type.
	MarshalType   reflect.Type      // The reflect.Type a field must be converted to when marshaling or nil when it is assignable directly. (Field->value)
	Name          string            // Field name or value of the name tag (like in `ql:"name foo"`).
	ReflectType   reflect.Type      // The reflect.Type of the field.
	Tags          map[string]string // QL tags of this field. (`ql:"a, b c, d"` -> {"a": "", "b": "c", "d": ""})
	Type          Type              // QL type of the field.
	UnmarshalType reflect.Type      // The reflect.Type a value must be converted to when unmarshaling or nil when it is assignable directly. (Field<-value)
	ZeroPtr       reflect.Value     // The reflect.Zero value of the field if it's a pointer type.
}

func (s *StructField) check(v interface{}) error {
	t := reflect.TypeOf(v)
	if !s.ReflectType.AssignableTo(t) {
		if !s.ReflectType.ConvertibleTo(t) {
			return fmt.Errorf("type %s (%v) cannot be converted to %T", s.ReflectType.Name(), s.ReflectType.Kind(), t.Name())
		}

		s.MarshalType = t
	}

	if !t.AssignableTo(s.ReflectType) {
		if !t.ConvertibleTo(s.ReflectType) {
			return fmt.Errorf("type %s (%v) cannot be converted to %T", t.Name(), t.Kind(), s.ReflectType.Name())
		}

		s.UnmarshalType = s.ReflectType
	}
	return nil
}

func parseTag(s string) map[string]string {
	m := map[string]string{}
	for _, v := range strings.Split(s, ",") {
		v = strings.TrimSpace(v)
		switch n := strings.IndexRune(v, ' '); {
		case n < 0:
			m[v] = ""
		default:
			m[v[:n]] = v[n+1:]
		}
	}
	return m
}

// StructSchema returns StructInfo for v which must be a struct instance or a
// pointer to a struct.  The info is computed only once for every type.
// Subsequent calls to StructSchema for the same type return a cached
// StructInfo.
//
// Note: The returned StructSchema is shared and must be not mutated, including
// any other data structures it may point to.
func StructSchema(v interface{}) (*StructInfo, error) {
	if v == nil {
		return nil, fmt.Errorf("cannot derive schema for %T(%v)", v, v)
	}

	typ := reflect.TypeOf(v)
	schemaMu.RLock()
	if r, ok := schemaCache[typ]; ok {
		schemaMu.RUnlock()
		return r, nil
	}

	schemaMu.RUnlock()
	var schemaPtr bool
	t := typ
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
		schemaPtr = true
	}
	if k := t.Kind(); k != reflect.Struct {
		return nil, fmt.Errorf("cannot derive schema for type %T (%v)", v, k)
	}

	r := &StructInfo{IsPtr: schemaPtr}
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		fn := f.Name
		if !ast.IsExported(fn) {
			continue
		}

		tags := parseTag(f.Tag.Get("ql"))
		if _, ok := tags["-"]; ok {
			continue
		}

		if s := tags["name"]; s != "" {
			fn = s
		}

		if fn == "ID" && f.Type.Kind() == reflect.Int64 {
			r.HasID = true
		}
		var ix, unique bool
		var xn string
		xfn := fn
		if s := tags["index"]; s != "" {
			if _, ok := tags["uindex"]; ok {
				return nil, fmt.Errorf("both index and uindex in QL struct tag")
			}

			ix, xn = true, s
		} else if s := tags["uindex"]; s != "" {
			if _, ok := tags["index"]; ok {
				return nil, fmt.Errorf("both index and uindex in QL struct tag")
			}

			ix, unique, xn = true, true, s
		}
		if ix {
			if fn == "ID" && r.HasID {
				xfn = "id()"
			}
			r.Indices = append(r.Indices, &StructIndex{Name: xn, ColumnName: xfn, Unique: unique})
		}

		sf := &StructField{Index: i, Name: fn, Tags: tags, Type: Type(-1), ReflectType: f.Type}
		fk := sf.ReflectType.Kind()
		if fk == reflect.Ptr {
			sf.IsPtr = true
			sf.ZeroPtr = reflect.Zero(sf.ReflectType)
			sf.ReflectType = sf.ReflectType.Elem()
			fk = sf.ReflectType.Kind()
		}

		switch fk {
		case reflect.Bool:
			sf.Type = Bool
			if err := sf.check(false); err != nil {
				return nil, err
			}
		case reflect.Int, reflect.Uint:
			return nil, fmt.Errorf("only integers of fixed size can be used to derive a schema: %v", fk)
		case reflect.Int8:
			sf.Type = Int8
			if err := sf.check(int8(0)); err != nil {
				return nil, err
			}
		case reflect.Int16:
			if err := sf.check(int16(0)); err != nil {
				return nil, err
			}
			sf.Type = Int16
		case reflect.Int32:
			if err := sf.check(int32(0)); err != nil {
				return nil, err
			}
			sf.Type = Int32
		case reflect.Int64:
			if sf.ReflectType.Name() == "Duration" && sf.ReflectType.PkgPath() == "time" {
				sf.Type = Duration
				break
			}

			sf.Type = Int64
			if err := sf.check(int64(0)); err != nil {
				return nil, err
			}
		case reflect.Uint8:
			sf.Type = Uint8
			if err := sf.check(uint8(0)); err != nil {
				return nil, err
			}
		case reflect.Uint16:
			sf.Type = Uint16
			if err := sf.check(uint16(0)); err != nil {
				return nil, err
			}
		case reflect.Uint32:
			sf.Type = Uint32
			if err := sf.check(uint32(0)); err != nil {
				return nil, err
			}
		case reflect.Uint64:
			sf.Type = Uint64
			if err := sf.check(uint64(0)); err != nil {
				return nil, err
			}
		case reflect.Float32:
			sf.Type = Float32
			if err := sf.check(float32(0)); err != nil {
				return nil, err
			}
		case reflect.Float64:
			sf.Type = Float64
			if err := sf.check(float64(0)); err != nil {
				return nil, err
			}
		case reflect.Complex64:
			sf.Type = Complex64
			if err := sf.check(complex64(0)); err != nil {
				return nil, err
			}
		case reflect.Complex128:
			sf.Type = Complex128
			if err := sf.check(complex128(0)); err != nil {
				return nil, err
			}
		case reflect.Slice:
			sf.Type = Blob
			if err := sf.check([]byte(nil)); err != nil {
				return nil, err
			}
		case reflect.Struct:
			switch sf.ReflectType.PkgPath() {
			case "math/big":
				switch sf.ReflectType.Name() {
				case "Int":
					sf.Type = BigInt
				case "Rat":
					sf.Type = BigRat
				}
			case "time":
				switch sf.ReflectType.Name() {
				case "Time":
					sf.Type = Time
				}
			}
		case reflect.String:
			sf.Type = String
			if err := sf.check(""); err != nil {
				return nil, err
			}
		}

		if sf.Type < 0 {
			return nil, fmt.Errorf("cannot derive schema for type %s (%v)", sf.ReflectType.Name(), fk)
		}

		sf.IsID = fn == "ID" && r.HasID
		r.Fields = append(r.Fields, sf)
	}

	schemaMu.Lock()
	schemaCache[typ] = r
	if t != typ {
		r2 := *r
		r2.IsPtr = false
		schemaCache[t] = &r2
	}
	schemaMu.Unlock()
	return r, nil
}

// MustStructSchema is like StructSchema but panics on error. It simplifies
// safe initialization of global variables holding StructInfo.
//
// MustStructSchema is safe for concurrent use by multiple goroutines.
func MustStructSchema(v interface{}) *StructInfo {
	s, err := StructSchema(v)
	if err != nil {
		panic(err)
	}

	return s
}

// SchemaOptions amend the result of Schema.
type SchemaOptions struct {
	// Don't wrap the CREATE statement(s) in a transaction.
	NoTransaction bool

	// Don't insert the IF NOT EXISTS clause in the CREATE statement(s).
	NoIfNotExists bool

	// Do not strip the "pkg." part from type name "pkg.Type", produce
	// "pkg_Type" table name instead. Applies only when no name is passed
	// to Schema().
	KeepPrefix bool
}

var zeroSchemaOptions SchemaOptions

// Schema returns a CREATE TABLE/INDEX statement(s) for a table derived from a
// struct or an error, if any.  The table is named using the name parameter. If
// name is an empty string then the type name of the struct is used while non
// conforming characters are replaced by underscores. Value v can be also a
// pointer to a struct.
//
// Every considered struct field type must be one of the QL types or a type
// convertible to string, bool, int*, uint*, float* or complex* type or pointer
// to such type. Integers with a width dependent on the architecture can not be
// used. Only exported fields are considered. If an exported field QL tag
// contains "-" (`ql:"-"`) then such field is not considered. A field with name
// ID, having type int64, corresponds to id() - and is thus not a part of the
// CREATE statement. A field QL tag containing "index name" or "uindex name"
// triggers additionally creating an index or unique index on the respective
// field.  Fields can be renamed using a QL tag "name newName".  Fields are
// considered in the order of appearance. A QL tag is a struct tag part
// prefixed by "ql:". Tags can be combined, for example:
//
//	type T struct {
//		Foo	string	`ql:"index xFoo, name Bar"`
//	}
//
// If opts.NoTransaction == true then the statement(s) are not wrapped in a
// transaction. If opt.NoIfNotExists == true then the CREATE statement(s) omits
// the IF NOT EXISTS clause. Passing nil opts is equal to passing
// &SchemaOptions{}
//
// Schema is safe for concurrent use by multiple goroutines.
func Schema(v interface{}, name string, opt *SchemaOptions) (List, error) {
	if opt == nil {
		opt = &zeroSchemaOptions
	}
	s, err := StructSchema(v)
	if err != nil {
		return List{}, err
	}

	var buf bytes.Buffer
	if !opt.NoTransaction {
		buf.WriteString("BEGIN TRANSACTION; ")
	}
	buf.WriteString("CREATE TABLE ")
	if !opt.NoIfNotExists {
		buf.WriteString("IF NOT EXISTS ")
	}
	if name == "" {
		name = fmt.Sprintf("%T", v)
		if !opt.KeepPrefix {
			a := strings.Split(name, ".")
			if l := len(a); l > 1 {
				name = a[l-1]
			}
		}
		nm := []rune{}
		for _, v := range name {
			switch {
			case v >= '0' && v <= '9' || v == '_' || v >= 'a' && v <= 'z' || v >= 'A' && v <= 'Z':
				// ok
			default:
				v = '_'
			}
			nm = append(nm, v)
		}
		name = string(nm)
	}
	buf.WriteString(name + " (")
	for _, v := range s.Fields {
		if v.IsID {
			continue
		}

		buf.WriteString(fmt.Sprintf("%s %s, ", v.Name, v.Type))
	}
	buf.WriteString("); ")
	for _, v := range s.Indices {
		buf.WriteString("CREATE ")
		if v.Unique {
			buf.WriteString("UNIQUE ")
		}
		buf.WriteString("INDEX ")
		if !opt.NoIfNotExists {
			buf.WriteString("IF NOT EXISTS ")
		}
		buf.WriteString(fmt.Sprintf("%s ON %s (%s); ", v.Name, name, v.ColumnName))
	}
	if !opt.NoTransaction {
		buf.WriteString("COMMIT; ")
	}
	l, err := Compile(buf.String())
	if err != nil {
		return List{}, fmt.Errorf("%s: %v", buf.String(), err)
	}

	return l, nil
}

// MustSchema is like Schema but panics on error. It simplifies safe
// initialization of global variables holding compiled schemas.
//
// MustSchema is safe for concurrent use by multiple goroutines.
func MustSchema(v interface{}, name string, opt *SchemaOptions) List {
	l, err := Schema(v, name, opt)
	if err != nil {
		panic(err)
	}

	return l
}

// Marshal converts, in the order of appearance, fields of a struct instance v
// to []interface{} or an error, if any. Value v can be also a pointer to a
// struct.
//
// Every considered struct field type must be one of the QL types or a type
// convertible to string, bool, int*, uint*, float* or complex* type or pointer
// to such type. Integers with a width dependent on the architecture can not be
// used. Only exported fields are considered. If an exported field QL tag
// contains "-" then such field is not considered. A QL tag is a struct tag
// part prefixed by "ql:".  Field with name ID, having type int64, corresponds
// to id() - and is thus not part of the result.
//
// Marshal is safe for concurrent use by multiple goroutines.
func Marshal(v interface{}) ([]interface{}, error) {
	s, err := StructSchema(v)
	if err != nil {
		return nil, err
	}

	val := reflect.ValueOf(v)
	if s.IsPtr {
		val = val.Elem()
	}
	n := len(s.Fields)
	if s.HasID {
		n--
	}
	r := make([]interface{}, n)
	j := 0
	for _, v := range s.Fields {
		if v.IsID {
			continue
		}

		f := val.Field(v.Index)
		if v.IsPtr {
			if f.IsNil() {
				r[j] = nil
				j++
				continue
			}

			f = f.Elem()
		}
		if m := v.MarshalType; m != nil {
			f = f.Convert(m)
		}
		r[j] = f.Interface()
		j++
	}
	return r, nil
}

// MustMarshal is like Marshal but panics on error. It simplifies marshaling of
// "safe" types, like eg. those which were already verified by Schema or
// MustSchema.  When the underlying Marshal returns an error, MustMarshal
// panics.
//
// MustMarshal is safe for concurrent use by multiple goroutines.
func MustMarshal(v interface{}) []interface{} {
	r, err := Marshal(v)
	if err != nil {
		panic(err)
	}

	return r
}

// Unmarshal stores data from []interface{} in the struct value pointed to by
// v.
//
// Every considered struct field type must be one of the QL types or a type
// convertible to string, bool, int*, uint*, float* or complex* type or pointer
// to such type. Integers with a width dependent on the architecture can not be
// used. Only exported fields are considered. If an exported field QL tag
// contains "-" then such field is not considered. A QL tag is a struct tag
// part prefixed by "ql:".  Fields are considered in the order of appearance.
// Types of values in data must be compatible with the corresponding considered
// field of v.
//
// If the struct has no ID field then the number of values in data must be equal
// to the number of considered fields of v.
//
//	type T struct {
//		A bool
//		B string
//	}
//
// Assuming the schema is
//
//	CREATE TABLE T (A bool, B string);
//
// Data might be a result of queries like
//
//	SELECT * FROM T;
//	SELECT A, B FROM T;
//
// If the struct has a considered ID field then the number of values in data
// must be equal to the number of considered fields in v - or one less. In the
// later case the ID field is not set.
//
//	type U struct {
//		ID int64
//		A  bool
//		B  string
//	}
//
// Assuming the schema is
//
//	CREATE TABLE T (A bool, B string);
//
// Data might be a result of queries like
//
//	SELECT * FROM T;             // ID not set
//	SELECT A, B FROM T;          // ID not set
//	SELECT id(), A, B FROM T;    // ID is set
//
// To unmarshal a value from data into a pointer field of v, Unmarshal first
// handles the case of the value being nil. In that case, Unmarshal sets the
// pointer to nil. Otherwise, Unmarshal unmarshals the data value into value
// pointed at by the pointer. If the pointer is nil, Unmarshal allocates a new
// value for it to point to.
//
// Unmarshal is safe for concurrent use by multiple goroutines.
func Unmarshal(v interface{}, data []interface{}) (err error) {
	defer func() {
		if r := recover(); r != nil {
			var ok bool
			if err, ok = r.(error); !ok {
				err = fmt.Errorf("%v", r)
			}
			err = fmt.Errorf("unmarshal: %v", err)
		}
	}()

	s, err := StructSchema(v)
	if err != nil {
		return err
	}

	if !s.IsPtr {
		return fmt.Errorf("unmarshal: need a pointer to a struct")
	}

	id := false
	nv, nf := len(data), len(s.Fields)
	switch s.HasID {
	case true:
		switch {
		case nv == nf:
			id = true
		case nv == nf-1:
			// ok
		default:
			return fmt.Errorf("unmarshal: got %d values, need %d or %d", nv, nf-1, nf)
		}
	default:
		switch {
		case nv == nf:
			// ok
		default:
			return fmt.Errorf("unmarshal: got %d values, need %d", nv, nf)
		}
	}

	j := 0
	vVal := reflect.ValueOf(v)
	if s.IsPtr {
		vVal = vVal.Elem()
	}
	for _, sf := range s.Fields {
		if sf.IsID && !id {
			continue
		}

		d := data[j]
		val := reflect.ValueOf(d)
		j++

		fVal := vVal.Field(sf.Index)
		if u := sf.UnmarshalType; u != nil {
			val = val.Convert(u)
		}
		if !sf.IsPtr {
			fVal.Set(val)
			continue
		}

		if d == nil {
			fVal.Set(sf.ZeroPtr)
			continue
		}

		if fVal.IsNil() {
			fVal.Set(reflect.New(sf.ReflectType))
		}

		fVal.Elem().Set(val)
	}
	return nil
}