package automapper

import (
        "fmt"
        "reflect"
)

type Config[S any, D any] struct {
        fieldMappings map[string]Opts
        destType      reflect.Type
        destFields    int
        srcType       reflect.Type
        srcFields     int
}

// New creates a new config for mapping from S (source) to D (destination)
func New[S any, D any]() Config[S, D] {
        dest := new(D)
        src := new(S)
        destType := reflect.TypeOf(*dest)
        srcType := reflect.TypeOf(*src)

        if destType.Kind() != reflect.Struct || destType.Kind() == reflect.Ptr && destType.Elem().Kind() != reflect.Struct {
                // must be a pointer to a struct
                panic("destination type D was not a struct or pointer to one")
        }

        if srcType.Kind() != reflect.Struct || srcType.Kind() == reflect.Ptr && srcType.Elem().Kind() != reflect.Struct {
                // must be a pointer to a struct
                panic("source type T was not a struct or pointer to one")
        }

        m := Config[S, D]{
                fieldMappings: map[string]Opts{},
                destType:      destType,
                destFields:    destType.NumField(),
                srcType:       srcType,
                srcFields:     srcType.NumField(),
        }
        return m
}

type IncompatibleTypesErr struct {
        src  reflect.Type
        dest reflect.Type
}

func (i IncompatibleTypesErr) Error() string {
        return fmt.Sprintf("destination type is %s, source is %s", i.dest, i.src)
}

func (m Config[S, D]) mapAny(srcType reflect.Type, srcValue reflect.Value, destType reflect.Type, destValue reflect.Value) error {

        switch destType.Kind() {
        case reflect.Struct:
                if srcType.Kind() != reflect.Struct {
                        return IncompatibleTypesErr{src: srcType, dest: destType}
                }
                if srcType != destType {
                        return IncompatibleTypesErr{src: srcType, dest: destType}
                }
                destValue.Set(srcValue)
                return nil

        case reflect.Slice:
                if srcType.Kind() != reflect.Slice {
                        return IncompatibleTypesErr{src: srcType, dest: destType}
                }

                if srcType.Elem().Kind() != destType.Elem().Kind() {
                        return IncompatibleTypesErr{src: srcType, dest: destType}
                }
                if srcValue.IsNil() {
                        return nil
                }
                if srcType.Elem() != destType.Elem() {
                        // need to cast
                        destValue.Set(reflect.MakeSlice(destType, srcValue.Len(), srcValue.Len()))
                        for i := 0; i < srcValue.Len(); i++ {
                                elemValue := srcValue.Index(i)
                                destValue.Index(i).Set(elemValue.Convert(destType.Elem()))
                        }
                        return nil
                }
                destValue.Set(srcValue)
        case reflect.Pointer:
                referencedDestType := destType.Elem()
                referencedSourceType := srcType.Elem()
                if referencedSourceType.Kind() != referencedDestType.Kind() {
                        return IncompatibleTypesErr{src: srcType, dest: destType}
                }

                if srcValue.IsNil() {
                        return nil
                }

                if referencedSourceType == referencedDestType {
                        destValue.Set(srcValue)
                }
                destValue.Set(srcValue.Convert(destValue.Type()))
        default:
                if srcType.Kind() != destType.Kind() {
                        return IncompatibleTypesErr{src: srcType, dest: destType}
                }
                if destValue.Type() != srcValue.Type() {
                        srcValue = srcValue.Convert(destValue.Type())
                }

                destValue.Set(srcValue)
        }
        return nil
}

// MapSlice maps slices...
func (m Config[S, D]) MapSlice(src []S) ([]D, error) {

        var ret []D
        for _, item := range src {
                mappedItem, err := m.Map(item)
                if err != nil {
                        return nil, err
                }
                ret = append(ret, mappedItem)
        }
        return ret, nil
}

// Map from S (source type) to D (destination type)
func (m Config[S, D]) Map(src S) (D, error) {
        dest := new(D)

        srcValue := reflect.ValueOf(&src)
        srcType := m.srcType
        destValue := reflect.ValueOf(dest)
        destType := m.destType

        for j := 0; j < m.destFields; j++ {
                destFieldType := destType.Field(j)
                if !destFieldType.IsExported() {
                        continue
                }

                destFieldValue := destValue.Elem().Field(j)
                found := false
                fieldMapping, ok := m.fieldMappings[destFieldType.Name]
                if ok {
                        err := fieldMapping.apply(src, destFieldValue)
                        if err != nil {
                                return *dest, err
                        }
                        continue
                }
                for i := 0; i < m.srcFields; i++ {
                        srcFieldValue := srcValue.Elem().Field(i)
                        srcFieldType := srcType.Field(i)
                        if destFieldType.Name == srcFieldType.Name {
                                found = true
                                if err := m.mapAny(srcFieldType.Type, srcFieldValue, destFieldType.Type, destFieldValue); err != nil {
                                        return *dest, err
                                }
                                break
                        }
                }
                if !found {
                        return *dest, fmt.Errorf("field '%s' not found in source type '%s'", destFieldType.Name, reflect.TypeOf(src))
                }
        }

        return *dest, nil
}

type Opts struct {
        mapFunc func(any) (any, error)
        ignore  bool
}

func (o Opts) apply(src any, destValue reflect.Value) error {
        if o.ignore {
                return nil
        }
        if o.mapFunc == nil {
                return nil
        }

        v, err := o.mapFunc(src)
        if err != nil {
                return err
        }
        destValue.Set(reflect.ValueOf(v))
        return nil
}

// IgnoreField asks the Config to avoid mapping this field
func IgnoreField() func(o *Opts) {
        return func(o *Opts) {
                o.ignore = true
        }
}

// MapField asks the config to map with the mapFunc
func MapField[S any](mapFunc func(S) (any, error)) func(o *Opts) {
        return func(o *Opts) {
                o.mapFunc = func(s any) (any, error) {
                        return mapFunc(s.(S))
                }
        }
}

// findStructField looks for a field in the given struct.
// The field being looked for should be a pointer to the actual struct field.
// If found, the field info will be returned. Otherwise, nil will be returned.
// From https://github.com/go-ozzo/ozzo-validation
func findStructField(structValue reflect.Value, fieldValue reflect.Value) *reflect.StructField {
        ptr := fieldValue.Pointer()
        for i := structValue.NumField() - 1; i >= 0; i-- {
                sf := structValue.Type().Field(i)
                if ptr == structValue.Field(i).UnsafeAddr() {
                        // do additional type comparison because it's possible that the address of
                        // an embedded struct is the same as the first field of the embedded struct
                        if sf.Type == fieldValue.Elem().Type() {
                                return &sf
                        }
                }
                if sf.Anonymous {
                        // delve into anonymous struct to look for the field
                        fi := structValue.Field(i)
                        if sf.Type.Kind() == reflect.Ptr {
                                fi = fi.Elem()
                        }
                        if fi.Kind() == reflect.Struct {
                                if f := findStructField(fi, fieldValue); f != nil {
                                        return f
                                }
                        }
                }
        }
        return nil
}

// ForFieldName registers mapping options by the struct field's name
func (m Config[S, D]) ForFieldName(name string, option func(o *Opts)) Config[S, D] {
        _, found := m.destType.FieldByName(name)
        if !found {
                panic(fmt.Errorf("destination has no field named %s", name))
        }
        opts, found := m.fieldMappings[name]
        if !found {
                opts = Opts{}
        }
        option(&opts)
        m.fieldMappings[name] = opts
        return m
}

// ForField registers mapping options by a fieldFunc. The fieldFunc MUST return a pointer to a struct field of *D.
// ForField(func(d *Foo) any { return &d.Bar }, ...)
func (m Config[S, D]) ForField(fieldFunc func(d *D) any, option func(o *Opts)) Config[S, D] {
        d := new(D)
        field := fieldFunc(d)
        structValue := reflect.ValueOf(d)
        fieldValue := reflect.ValueOf(field)

        structValue = structValue.Elem()

        if fieldValue.Kind() != reflect.Ptr {
                panic("fieldFunc return value must be pointer to struct field")
        }

        structField := findStructField(structValue, fieldValue)
        if structField == nil {
                panic(fmt.Errorf("struct field could not be identified from fieldFunc"))
        }

        return m.ForFieldName(structField.Name, option)
}

// MapSlice generic helper to map []A to []B
func MapSlice[A, B any](slice []A, mapper func(input A) B) (res []B) {
        for _, item := range slice {
                res = append(res, mapper(item))
        }
        return
}