package one2one

import (
	"encoding/json"
	"git.sxidc.com/go-framework/baize/convenient/binding"
	"git.sxidc.com/go-framework/baize/convenient/binding/request"
	"git.sxidc.com/go-framework/baize/framwork/api"
	"git.sxidc.com/go-framework/baize/framwork/domain"
	"git.sxidc.com/go-framework/baize/framwork/infrastructure"
	"git.sxidc.com/go-framework/baize/framwork/infrastructure/database"
	"git.sxidc.com/go-framework/baize/framwork/infrastructure/database/sql"
	"git.sxidc.com/go-tools/utils/strutils"
	"git.sxidc.com/service-supports/fserr"
)

func Update(fromTableName string, fromRelationFieldName string, fromRelationColumnName string, toTableName string, toDomainCNName string, toRelationColumnName string) binding.ServiceFunc[any] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
		object := objects[0]
		if object == nil {
			return nil, fserr.New("领域实体为空")
		}

		fromEntity, ok := object.(domain.Entity)
		if !ok {
			return nil, fserr.New("领域对象不是实体")
		}

		// 字段校验
		err := fromEntity.CheckFieldID(fromEntity.DomainCNName())
		if err != nil {
			return nil, err
		}

		if !domain.HasField(object, fromRelationFieldName) {
			return nil, fserr.New("关联字段" + fromRelationFieldName + "不存在")
		}

		// from存在性校验
		fromExist, err := database.CheckExist(i.DBExecutor(), &sql.CheckExistExecuteParams{
			TableName:  fromTableName,
			Conditions: sql.NewConditions().Equal(domain.ColumnID, fromEntity.GetID()),
		})
		if err != nil {
			return nil, err
		}

		if !fromExist {
			return nil, fserr.New(fromEntity.DomainCNName() + "不存在")
		}

		toID, err := domain.Field[string](object, fromRelationFieldName)
		if err != nil {
			return nil, err
		}

		if strutils.IsStringNotEmpty(toID) {
			// to存在性校验
			toExist, err := database.CheckExist(i.DBExecutor(), &sql.CheckExistExecuteParams{
				TableName:  toTableName,
				Conditions: sql.NewConditions().Equal(domain.ColumnID, toID),
			})
			if err != nil {
				return nil, err
			}

			if !toExist {
				return nil, fserr.New(fromEntity.DomainCNName() + "关联的" + toDomainCNName + "不存在")
			}
		}

		err = database.Transaction(i.DBExecutor(), func(tx database.Executor) error {
			if strutils.IsStringNotEmpty(fromTableName) {
				err := database.Update(tx, &sql.UpdateExecuteParams{
					TableName:  fromTableName,
					TableRow:   sql.NewTableRow().Add(fromRelationColumnName, toID),
					Conditions: sql.NewConditions().Equal(domain.ColumnID, fromEntity.GetID()),
				})
				if err != nil {
					return err
				}
			}

			if strutils.IsStringNotEmpty(toTableName) {
				err := database.Update(tx, &sql.UpdateExecuteParams{
					TableName:  toTableName,
					TableRow:   sql.NewTableRow().Add(toRelationColumnName, fromEntity.GetID()),
					Conditions: sql.NewConditions().Equal(domain.ColumnID, toID),
				})
				if err != nil {
					return err
				}
			}

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

		return nil, nil
	}
}

func Query[TI any](tableName string) binding.ServiceFunc[TI] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (TI, error) {
		var info TI
		return info, nil
	}
}

func QueryWithOtherInfo[FI any, TI any](tableName string) binding.ServiceFunc[map[string]any] {
	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (map[string]any, error) {
		info := new(struct {
			Self FI `json:"self"`
			With TI `json:"with"`
		})

		infoJson, err := json.Marshal(info)
		if err != nil {
			return nil, err
		}

		retMap := make(map[string]any)
		err = json.Unmarshal(infoJson, &retMap)
		if err != nil {
			return nil, err
		}

		return retMap, nil
	}
}