package convx

import (
	"errors"
	"strconv"
)

// interface 转 int64
func ToInt64(val interface{}) (i int64, err error) {
	if val == nil {
		return 0, errors.New("value is nil")
	}

	if v, ok := val.(int64); ok {
		return v, nil
	} else if v, ok := val.(int32); ok {
		return int64(v), nil
	} else if v, ok := val.(string); ok {
		// string 转 int64
		// 第二个参数为基数（2~36），第三个参数位大小表示期望转换的结果类型，其值可以为0, 8, 16, 32和64，分别对应 int, int8, int16, int32和int64
		var i int64
		i, err = strconv.ParseInt(v, 10, 64)
		if err != nil {
			return 0, errors.New("string to int64 error")
		}
		return i, nil
	} else if v, ok := val.(float64); ok {
		return int64(v), nil
	} else if v, ok := val.(float32); ok {
		return int64(v), nil
	} else if v, ok := val.(int); ok {
		return int64(v), nil
	} else if v, ok := val.(uint); ok {
		return int64(v), nil
	} else if v, ok := val.(uint32); ok {
		return int64(v), nil
	} else if v, ok := val.(uint64); ok {
		return int64(v), nil
	} else if v, ok := val.(bool); ok {
		if v {
			return 1, nil
		} else {
			return 0, nil
		}
	} else {
		return 0, errors.New("不支持的参数类型")
	}
}



// 泛型的实现


// package main

// import (
// 	"errors"
// 	"fmt"
// 	"reflect"
// 	"strconv"
// )

// 定义一个约束，用于限制可以被转换为int64的类型
type Int64Convertible interface {
	toInt64() int64
}

// 实现toInt64方法，用于转换为int64
func (i *int64) toInt64() int64 {
	return *i
}

// 使用泛型约束来定义函数
func ToInt642[T any](val T) (int64, error) where T: Int64Convertible {
	v := reflect.ValueOf(val)
	t := v.Type()

	if v.IsNil() {
		return 0, errors.New("值为nil")
	}

	switch v.Kind() {
	case reflect.String:
		i, err := strconv.ParseInt(v.String(), 10, 64)
		if err != nil {
			return 0, fmt.Errorf("无法将字符串转换为int64: %w", err)
		}
		return i, nil
	case reflect.Bool:
		if v.Bool() {
			return 1, nil
		}
		return 0, nil
	default:
		return v.Interface().(Int64Convertible).toInt64(), nil
	}
}

// 添加对指针类型的处理
func ToInt64[T any](val T) (int64, error) where T: Int64Convertible {
	v := reflect.ValueOf(val)
	t := v.Type()

	if v.IsNil() {
		return 0, errors.New("值为nil")
	}

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

	switch v.Kind() {
	case reflect.String:
		i, err := strconv.ParseInt(v.String(), 10, 64)
		if err != nil {
			return 0, fmt.Errorf("无法将字符串转换为int64: %w", err)
		}
		return i, nil
	case reflect.Bool:
		if v.Bool() {
			return 1, nil
		}
		return 0, nil
	default:
		return v.Interface().(Int64Convertible).toInt64(), nil
	}
}