package treeprint

import (
	"fmt"
	"reflect"
	"strings"
)

type StructTreeOption int

const (
	StructNameTree StructTreeOption = iota
	StructValueTree
	StructTagTree
	StructTypeTree
	StructTypeSizeTree
)

func FromStruct(v interface{}, opt ...StructTreeOption) (Tree, error) {
	var treeOpt StructTreeOption
	if len(opt) > 0 {
		treeOpt = opt[0]
	}
	switch treeOpt {
	case StructNameTree:
		tree := New()
		err := nameTree(tree, v)
		return tree, err
	case StructValueTree:
		tree := New()
		err := valueTree(tree, v)
		return tree, err
	case StructTagTree:
		tree := New()
		err := tagTree(tree, v)
		return tree, err
	case StructTypeTree:
		tree := New()
		err := typeTree(tree, v)
		return tree, err
	case StructTypeSizeTree:
		tree := New()
		err := typeSizeTree(tree, v)
		return tree, err
	default:
		err := fmt.Errorf("treeprint: invalid StructTreeOption %v", treeOpt)
		return nil, err
	}
}

type FmtFunc func(name string, v interface{}) (string, bool)

func FromStructWithMeta(v interface{}, fmtFunc FmtFunc) (Tree, error) {
	if fmtFunc == nil {
		tree := New()
		err := nameTree(tree, v)
		return tree, err
	}
	tree := New()
	err := metaTree(tree, v, fmtFunc)
	return tree, err
}

func Repr(v interface{}) string {
	tree := New()
	vType := reflect.TypeOf(v)
	vValue := reflect.ValueOf(v)
	_, val, isStruct := getValue(vType, &vValue)
	if !isStruct {
		return fmt.Sprintf("%+v", val.Interface())
	}
	err := valueTree(tree, val.Interface())
	if err != nil {
		return err.Error()
	}
	return tree.String()
}

func nameTree(tree Tree, v interface{}) error {
	typ, val, err := checkType(v)
	if err != nil {
		return err
	}
	fields := typ.NumField()
	for i := 0; i < fields; i++ {
		field := typ.Field(i)
		fieldValue := val.Field(i)
		name, skip, omit := getMeta(field.Name, field.Tag)
		if skip || omit && isEmpty(&fieldValue) {
			continue
		}
		typ, val, isStruct := getValue(field.Type, &fieldValue)
		if !isStruct {
			tree.AddNode(name)
			continue
		} else if subNum := typ.NumField(); subNum == 0 {
			tree.AddNode(name)
			continue
		}
		branch := tree.AddBranch(name)
		if err := nameTree(branch, val.Interface()); err != nil {
			err := fmt.Errorf("%v on struct branch %s", err, name)
			return err
		}
	}
	return nil
}

func getMeta(fieldName string, tag reflect.StructTag) (name string, skip, omit bool) {
	if tagStr := tag.Get("tree"); len(tagStr) > 0 {
		name, omit = tagSpec(tagStr)
	}
	if name == "-" {
		return fieldName, true, omit
	}
	if len(name) == 0 {
		name = fieldName
	} else if trimmed := strings.TrimSpace(name); len(trimmed) == 0 {
		name = fieldName
	}
	return
}

func valueTree(tree Tree, v interface{}) error {
	typ, val, err := checkType(v)
	if err != nil {
		return err
	}
	fields := typ.NumField()
	for i := 0; i < fields; i++ {
		field := typ.Field(i)
		fieldValue := val.Field(i)
		name, skip, omit := getMeta(field.Name, field.Tag)
		if skip || omit && isEmpty(&fieldValue) {
			continue
		}
		typ, val, isStruct := getValue(field.Type, &fieldValue)
		if !isStruct {
			tree.AddMetaNode(val.Interface(), name)
			continue
		} else if subNum := typ.NumField(); subNum == 0 {
			tree.AddMetaNode(val.Interface(), name)
			continue
		}
		branch := tree.AddBranch(name)
		if err := valueTree(branch, val.Interface()); err != nil {
			err := fmt.Errorf("%v on struct branch %s", err, name)
			return err
		}
	}
	return nil
}

func tagTree(tree Tree, v interface{}) error {
	typ, val, err := checkType(v)
	if err != nil {
		return err
	}
	fields := typ.NumField()
	for i := 0; i < fields; i++ {
		field := typ.Field(i)
		fieldValue := val.Field(i)
		name, skip, omit := getMeta(field.Name, field.Tag)
		if skip || omit && isEmpty(&fieldValue) {
			continue
		}
		filteredTag := filterTags(field.Tag)
		typ, val, isStruct := getValue(field.Type, &fieldValue)
		if !isStruct {
			tree.AddMetaNode(filteredTag, name)
			continue
		} else if subNum := typ.NumField(); subNum == 0 {
			tree.AddMetaNode(filteredTag, name)
			continue
		}
		branch := tree.AddMetaBranch(filteredTag, name)
		if err := tagTree(branch, val.Interface()); err != nil {
			err := fmt.Errorf("%v on struct branch %s", err, name)
			return err
		}
	}
	return nil
}

func typeTree(tree Tree, v interface{}) error {
	typ, val, err := checkType(v)
	if err != nil {
		return err
	}
	fields := typ.NumField()
	for i := 0; i < fields; i++ {
		field := typ.Field(i)
		fieldValue := val.Field(i)
		name, skip, omit := getMeta(field.Name, field.Tag)
		if skip || omit && isEmpty(&fieldValue) {
			continue
		}
		typ, val, isStruct := getValue(field.Type, &fieldValue)
		typename := fmt.Sprintf("%T", val.Interface())
		if !isStruct {
			tree.AddMetaNode(typename, name)
			continue
		} else if subNum := typ.NumField(); subNum == 0 {
			tree.AddMetaNode(typename, name)
			continue
		}
		branch := tree.AddMetaBranch(typename, name)
		if err := typeTree(branch, val.Interface()); err != nil {
			err := fmt.Errorf("%v on struct branch %s", err, name)
			return err
		}
	}
	return nil
}

func typeSizeTree(tree Tree, v interface{}) error {
	typ, val, err := checkType(v)
	if err != nil {
		return err
	}
	fields := typ.NumField()
	for i := 0; i < fields; i++ {
		field := typ.Field(i)
		fieldValue := val.Field(i)
		name, skip, omit := getMeta(field.Name, field.Tag)
		if skip || omit && isEmpty(&fieldValue) {
			continue
		}
		typ, val, isStruct := getValue(field.Type, &fieldValue)
		typesize := typ.Size()
		if !isStruct {
			tree.AddMetaNode(typesize, name)
			continue
		} else if subNum := typ.NumField(); subNum == 0 {
			tree.AddMetaNode(typesize, name)
			continue
		}
		branch := tree.AddMetaBranch(typesize, name)
		if err := typeSizeTree(branch, val.Interface()); err != nil {
			err := fmt.Errorf("%v on struct branch %s", err, name)
			return err
		}
	}
	return nil
}

func metaTree(tree Tree, v interface{}, fmtFunc FmtFunc) error {
	typ, val, err := checkType(v)
	if err != nil {
		return err
	}
	fields := typ.NumField()
	for i := 0; i < fields; i++ {
		field := typ.Field(i)
		fieldValue := val.Field(i)
		name, skip, omit := getMeta(field.Name, field.Tag)
		if skip || omit && isEmpty(&fieldValue) {
			continue
		}
		typ, val, isStruct := getValue(field.Type, &fieldValue)
		formatted, show := fmtFunc(name, val.Interface())
		if !isStruct {
			if show {
				tree.AddMetaNode(formatted, name)
				continue
			}
			tree.AddNode(name)
			continue
		} else if subNum := typ.NumField(); subNum == 0 {
			if show {
				tree.AddMetaNode(formatted, name)
				continue
			}
			tree.AddNode(name)
			continue
		}
		var branch Tree
		if show {
			branch = tree.AddMetaBranch(formatted, name)
		} else {
			branch = tree.AddBranch(name)
		}
		if err := metaTree(branch, val.Interface(), fmtFunc); err != nil {
			err := fmt.Errorf("%v on struct branch %s", err, name)
			return err
		}
	}
	return nil
}

func getValue(typ reflect.Type, val *reflect.Value) (reflect.Type, *reflect.Value, bool) {
	switch typ.Kind() {
	case reflect.Ptr:
		typ = typ.Elem()
		if typ.Kind() == reflect.Struct {
			elem := val.Elem()
			return typ, &elem, true
		}
	case reflect.Struct:
		return typ, val, true
	}
	return typ, val, false
}

func checkType(v interface{}) (reflect.Type, *reflect.Value, error) {
	typ := reflect.TypeOf(v)
	val := reflect.ValueOf(v)
	switch typ.Kind() {
	case reflect.Ptr:
		typ = typ.Elem()
		if typ.Kind() != reflect.Struct {
			err := fmt.Errorf("treeprint: %T is not a struct we could work with", v)
			return nil, nil, err
		}
		val = val.Elem()
	case reflect.Struct:
	default:
		err := fmt.Errorf("treeprint: %T is not a struct we could work with", v)
		return nil, nil, err
	}
	return typ, &val, nil
}