package gql

import (
	"fmt"
	"reflect"
	"strings"

	"github.com/graphql-go/graphql"
)

// TAG is the tag used for json
const TAG = "json"

// BindFields can't take recursive slice type
// e.g
// type Person struct{
//	Friends []Person
// }
// it will throw panic stack-overflow
func BindFields(t reflect.Type) graphql.Fields {
	fields := make(map[string]*graphql.Field)

	if t.Kind() == reflect.Ptr {
		t = t.Elem()
	}

	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)

		// Skip private fields
		if field.Tag.Get("private") == "true" {
			continue
		}

		tag := extractTag(field.Tag)

		if tag == "-" {
			continue
		}

		fieldType := field.Type

		if fieldType.Kind() == reflect.Ptr {
			fieldType = fieldType.Elem()
		}

		var graphType graphql.Output

		if fieldType.Kind() == reflect.Struct {
			structFields := BindFields(t.Field(i).Type)

			if tag == "" {
				fields = appendFields(fields, structFields)
				continue
			} else {
				graphType = graphql.NewObject(graphql.ObjectConfig{
					Name:   t.Name() + "_" + field.Name,
					Fields: structFields,
				})
			}
		}

		if tag == "" {
			continue
		}

		if graphType == nil {
			graphType = getGraphType(fieldType)
		}

		fields[tag] = &graphql.Field{
			Type: graphType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return extractValue(tag, p.Source), nil
			},
		}
	}
	return fields
}

func getGraphType(tipe reflect.Type) graphql.Output {
	kind := tipe.Kind()

	switch kind {
	case reflect.String:
		return graphql.String
	case reflect.Int:
		fallthrough
	case reflect.Int8:
		fallthrough
	case reflect.Int32:
		fallthrough
	case reflect.Int64:
		return graphql.Int
	case reflect.Float32:
		fallthrough
	case reflect.Float64:
		return graphql.Float
	case reflect.Bool:
		return graphql.Boolean
	case reflect.Slice:
		return getGraphList(tipe)
	}

	return graphql.String
}

func getGraphList(tipe reflect.Type) *graphql.List {
	if tipe.Kind() == reflect.Slice {
		switch tipe.Elem().Kind() {
		case reflect.Int:
			fallthrough
		case reflect.Int8:
			fallthrough
		case reflect.Int32:
			fallthrough
		case reflect.Int64:
			return graphql.NewList(graphql.Int)
		case reflect.Bool:
			return graphql.NewList(graphql.Boolean)
		case reflect.Float32:
			fallthrough
		case reflect.Float64:
			return graphql.NewList(graphql.Float)
		case reflect.String:
			return graphql.NewList(graphql.String)
		}
	}

	// finally bind object
	t := reflect.New(tipe.Elem())
	name := strings.Replace(fmt.Sprint(tipe.Elem()), ".", "_", -1)
	obj := graphql.NewObject(graphql.ObjectConfig{
		Name:   name,
		Fields: BindFields(t.Elem().Type()),
	})

	return graphql.NewList(obj)
}

func appendFields(dest, origin graphql.Fields) graphql.Fields {
	for key, value := range origin {
		dest[key] = value
	}

	return dest
}

func extractValue(originTag string, obj interface{}) interface{} {
	val := reflect.Indirect(reflect.ValueOf(obj))

	for j := 0; j < val.NumField(); j++ {
		field := val.Type().Field(j)

		if field.Type.Kind() == reflect.Struct {
			res := extractValue(originTag, val.Field(j).Interface())
			if res != nil {
				return res
			}
		}

		if originTag == extractTag(field.Tag) {
			return reflect.Indirect(val.Field(j)).Interface()
		}
	}

	return nil
}

func extractTag(tag reflect.StructTag) string {
	t := tag.Get(TAG)

	if t != "" {
		t = strings.Split(t, ",")[0]
	}

	return t
}

// // BindArg is a lazy way of binding args
// func BindArg(obj interface{}, tags ...string) graphql.FieldConfigArgument {
// 	v := reflect.Indirect(reflect.ValueOf(obj))
// 	var config = make(graphql.FieldConfigArgument)

// 	for i := 0; i < v.NumField(); i++ {
// 		field := v.Type().Field(i)
// 		mytag := extractTag(field.Tag)

// 		if inArray(tags, mytag) {
// 			config[mytag] = &graphql.ArgumentConfig{
// 				Type: getGraphType(field.Type),
// 			}
// 		}
// 	}

// 	return config
// }

// func inArray(slice interface{}, item interface{}) bool {
// 	s := reflect.ValueOf(slice)

// 	if s.Kind() != reflect.Slice {
// 		panic("inArray() given a non-slice type")
// 	}

// 	for i := 0; i < s.Len(); i++ {
// 		if reflect.DeepEqual(item, s.Index(i).Interface()) {
// 			return true
// 		}
// 	}

// 	return false
// }