package sql

import (
	"fmt"
	"git.sxidc.com/go-framework/baize/framwork/tag/sql/sql_result"
	"git.sxidc.com/go-tools/utils/reflectutils"
	"git.sxidc.com/service-supports/fserr"
	"reflect"
	"strings"
	"time"
)

const (
	resultTimeMicroFormat = "2006-01-02T15:04:05.000000+08:00"
	resultTimeMilliFormat = "2006-01-02T15:04:05.000+08:00"
	resultTimeSecFormat   = "2006-01-02T15:04:05+08:00"
)

func ParseSqlResult(input any, e any) error {
	if input == nil {
		return nil
	}

	if e == nil {
		return nil
	}

	results, ok := input.([]Result)
	if !ok {
		tableRow, ok := input.(Result)
		if !ok {
			return fserr.New("输入数据应该为sdk.SqlResult或[]sdk.SqlResult")
		}

		results = []Result{tableRow}
	}

	typeCheckErr := fserr.New("可以接受的输出类型为结构指针或者结构slice的指针")
	outputValue := reflect.ValueOf(e)

	if outputValue.Kind() != reflect.Pointer {
		return typeCheckErr
	} else {
		outputElemValue := reflectutils.PointerValueElem(outputValue)

		if outputElemValue.Kind() != reflect.Struct && outputElemValue.Kind() != reflect.Slice {
			return typeCheckErr
		}

		if outputElemValue.Kind() == reflect.Slice && !reflectutils.IsSliceValueOf(outputElemValue, reflect.Struct) {
			return typeCheckErr
		}
	}

	outputElemValue := reflectutils.PointerValueElem(outputValue)

	// 构造输出实体slice
	var outputEntities reflect.Value
	if outputElemValue.Kind() == reflect.Struct {
		outputEntities = reflect.MakeSlice(reflect.SliceOf(outputElemValue.Type()), 0, 0)
	} else {
		outputEntities = reflect.MakeSlice(outputElemValue.Type(), 0, 0)
	}

	for _, result := range results {
		var outputEntityValue reflect.Value
		if outputElemValue.Kind() == reflect.Struct {
			outputEntityValue = reflect.New(outputElemValue.Type()).Elem()
		} else {
			outputEntityValue = reflect.New(outputElemValue.Type().Elem()).Elem()
		}

		outputEntity := outputEntityValue.Addr().Interface()

		err := sql_result.DefaultUsage(result, outputEntity)
		if err != nil {
			return err
		}

		// 保存输出实体
		outputEntities = reflect.Append(outputEntities, outputEntityValue)
	}

	// 将输出实体赋值给输出指针变量
	if outputElemValue.Kind() == reflect.Slice {
		outputElemValue.Set(outputEntities)
	} else {
		outputElemValue.Set(outputEntities.Index(0))
	}

	return nil
}

type Result map[string]any

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

	layout := resultTimeSecFormat

	timeZoneIndex := strings.LastIndex(value, "+08:")
	if timeZoneIndex != -1 {
		value = value[:timeZoneIndex]

		afterSecondIndex := strings.LastIndex(value, ".")
		if afterSecondIndex != -1 {
			if len(value)-afterSecondIndex-1 == 6 {
				layout = resultTimeMicroFormat
			} else if len(value)-afterSecondIndex-1 == 3 {
				layout = resultTimeMilliFormat
			}
		}
	}

	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
}