package dpsapi

import (
	"errors"
	"fmt"
	"git.sxidc.com/go-tools/api_binding/http_binding"
	"git.sxidc.com/go-tools/api_binding/http_binding/binding_context"
	"git.sxidc.com/go-tools/api_binding/http_binding/response"
	"git.sxidc.com/go-tools/api_binding/utils"
	"git.sxidc.com/service-supports/dps-sdk"
	"git.sxidc.com/service-supports/dps-sdk/client"
)

func ApiV1(binding *http_binding.Binding, dpsAddress string) {
	http_binding.PostBind(binding, &http_binding.SimpleBindItem[OperateParseRequest, map[string]any]{
		Path:         "/dpsv1/database/operate/parse",
		ResponseFunc: response.SendMapResponse,
		BusinessFunc: func(c *binding_context.Context, inputModel OperateParseRequest) (map[string]any, error) {
			parsedClauses, err := parseSql(inputModel.SQL)
			if err != nil {
				return nil, err
			}

			for _, parsedClause := range parsedClauses {
				switch clause := parsedClause.(type) {
				case *insertClause:
					return map[string]any{
						"parsed": insertMap(clause),
					}, nil
				case *deleteClause:
					return map[string]any{
						"parsed": deleteMap(clause),
					}, nil
				case *updateClause:
					return map[string]any{
						"parsed": updateMap(clause),
					}, nil
				case *selectClause:
					return map[string]any{
						"parsed": selectMap(clause),
					}, nil
				default:
					return nil, errors.New("不支持的SQL语句")
				}
			}

			return nil, nil
		},
	})

	http_binding.PostBind(binding, &http_binding.SimpleBindItem[OperateRequest, any]{
		Path:         "/dpsv1/database/operate",
		ResponseFunc: response.SendMsgResponse,
		BusinessFunc: func(c *binding_context.Context, inputModel OperateRequest) (any, error) {
			parsedClauses, err := parseSql(inputModel.SQL)
			if err != nil {
				return nil, err
			}

			dpsClient, err := dps.NewClient(dpsAddress, "v1", inputModel.DatabaseID)
			if err != nil {
				return nil, err
			}

			err = dpsClient.Transaction(func(tx client.Transaction) error {
				for _, parsedClause := range parsedClauses {
					switch clause := parsedClause.(type) {
					case *insertClause:
						return doInsert(inputModel, clause)
					case *deleteClause:
						return doDelete(inputModel, clause)
					case *updateClause:
						return doUpdate(inputModel, clause)
					case *selectClause:
						return doSelect(inputModel, clause)
					default:
						return errors.New("不支持的SQL语句")
					}
				}

				return nil
			})
			if err != nil {
				return nil, err
			}

			return nil, nil
		},
	})
}

func insertMap(clause *insertClause) map[string]any {
	return map[string]any{
		"table":       clause.table,
		"key_columns": clause.keyColumns,
		"table_rows":  clause.tableRows,
	}
}

func deleteMap(clause *deleteClause) map[string]any {
	return map[string]any{}
}

func updateMap(clause *updateClause) map[string]any {
	return map[string]any{}
}

func selectMap(clause *selectClause) map[string]any {
	return map[string]any{}
}

func doInsert(inputModel OperateRequest, clause *insertClause) error {
	version := inputModel.Version
	if utils.IsStringEmpty(version) {
		version = "v1"
	}

	fmt.Printf("%+#v\n", clause)

	return nil
}

func doDelete(inputModel OperateRequest, clause *deleteClause) error {
	version := inputModel.Version
	if utils.IsStringEmpty(version) {
		version = "v1"
	}

	return nil
}

func doUpdate(inputModel OperateRequest, clause *updateClause) error {
	version := inputModel.Version
	if utils.IsStringEmpty(version) {
		version = "v1"
	}

	return nil
}

func doSelect(inputModel OperateRequest, clause *selectClause) error {
	version := inputModel.Version
	if utils.IsStringEmpty(version) {
		version = "v1"
	}

	return nil
}