package sql

import (
	"fmt"
	"git.sxidc.com/go-tools/utils/reflectutils"
	"strings"
	"time"
)

const (
	sqlResultTimeMicroFormat = "2006-01-02T15:04:05.000000+08:00"
	sqlResultTimeMilliFormat = "2006-01-02T15:04:05.000+08:00"
	sqlResultTimeSecFormat   = "2006-01-02T15:04:05+08:00"
)

type Result map[string]any

func (result Result) ColumnValueStringAsTime(columnName string) time.Time {
	value, ok := result[columnName].(string)
	if !ok {
		return time.Time{}
	}

	var layout string

	if strings.HasSuffix(value, ".000000+08:00") {
		layout = sqlResultTimeMicroFormat
	} else if strings.HasSuffix(value, ".000+08:00") {
		layout = sqlResultTimeMilliFormat
	} else {
		layout = sqlResultTimeSecFormat
	}

	t, err := time.ParseInLocation(layout, value, time.Local)
	if err != nil {
		return time.Time{}
	}

	return t
}

func (result Result) ColumnValueBool(columnName string) bool {
	value, err := reflectutils.ToBool(result[columnName])
	if err != nil {
		fmt.Println(err)
		return false
	}

	return value
}

func (result Result) ColumnValueString(columnName string) string {
	value, err := reflectutils.ToString(result[columnName])
	if err != nil {
		fmt.Println(err)
		return ""
	}

	return value
}

func (result Result) ColumnValueInt(columnName string) int {
	value, err := reflectutils.ToInt64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return int(value)
}

func (result Result) ColumnValueInt8(columnName string) int8 {
	value, err := reflectutils.ToInt64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return int8(value)
}

func (result Result) ColumnValueInt16(columnName string) int16 {
	value, err := reflectutils.ToInt64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return int16(value)
}

func (result Result) ColumnValueInt32(columnName string) int32 {
	value, err := reflectutils.ToInt64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return int32(value)
}

func (result Result) ColumnValueInt64(columnName string) int64 {
	value, err := reflectutils.ToInt64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return value
}

func (result Result) ColumnValueUint(columnName string) uint {
	value, err := reflectutils.ToUint64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return uint(value)
}

func (result Result) ColumnValueUint8(columnName string) uint8 {
	value, err := reflectutils.ToUint64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return uint8(value)
}

func (result Result) ColumnValueUint16(columnName string) uint16 {
	value, err := reflectutils.ToUint64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return uint16(value)
}

func (result Result) ColumnValueUint32(columnName string) uint32 {
	value, err := reflectutils.ToUint64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return uint32(value)
}

func (result Result) ColumnValueUint64(columnName string) uint64 {
	value, err := reflectutils.ToUint64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return value
}

func (result Result) ColumnValueFloat32(columnName string) float32 {
	value, err := reflectutils.ToFloat64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return float32(value)
}

func (result Result) ColumnValueFloat64(columnName string) float64 {
	value, err := reflectutils.ToFloat64(result[columnName])
	if err != nil {
		fmt.Println(err)
		return 0
	}

	return value
}