/*
 * Copyright 2025 coze-dev Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package repository

import (
	"context"
	"fmt"
	"runtime/debug"

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/jinzhu/copier"
	"gorm.io/gorm"

	model "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/plugin"
	common "github.com/coze-dev/coze-studio/backend/api/model/plugin_develop_common"
	pluginConf "github.com/coze-dev/coze-studio/backend/domain/plugin/conf"
	"github.com/coze-dev/coze-studio/backend/domain/plugin/entity"
	"github.com/coze-dev/coze-studio/backend/domain/plugin/internal/dal"
	"github.com/coze-dev/coze-studio/backend/domain/plugin/internal/dal/query"
	"github.com/coze-dev/coze-studio/backend/infra/contract/idgen"
	"github.com/coze-dev/coze-studio/backend/pkg/errorx"
	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
	"github.com/coze-dev/coze-studio/backend/pkg/lang/slices"
	"github.com/coze-dev/coze-studio/backend/pkg/logs"
	"github.com/coze-dev/coze-studio/backend/types/errno"
)

type pluginRepoImpl struct {
	query *query.Query

	pluginDraftDAO   *dal.PluginDraftDAO
	pluginDAO        *dal.PluginDAO
	pluginVersionDAO *dal.PluginVersionDAO

	toolDraftDAO   *dal.ToolDraftDAO
	toolDAO        *dal.ToolDAO
	toolVersionDAO *dal.ToolVersionDAO
}

type PluginRepoComponents struct {
	IDGen idgen.IDGenerator
	DB    *gorm.DB
}

func NewPluginRepo(components *PluginRepoComponents) PluginRepository {
	return &pluginRepoImpl{
		query:            query.Use(components.DB),
		pluginDraftDAO:   dal.NewPluginDraftDAO(components.DB, components.IDGen),
		pluginDAO:        dal.NewPluginDAO(components.DB, components.IDGen),
		pluginVersionDAO: dal.NewPluginVersionDAO(components.DB, components.IDGen),
		toolDraftDAO:     dal.NewToolDraftDAO(components.DB, components.IDGen),
		toolDAO:          dal.NewToolDAO(components.DB, components.IDGen),
		toolVersionDAO:   dal.NewToolVersionDAO(components.DB, components.IDGen),
	}
}

func (p *pluginRepoImpl) CreateDraftPlugin(ctx context.Context, plugin *entity.PluginInfo) (pluginID int64, err error) {
	pluginID, err = p.pluginDraftDAO.Create(ctx, plugin)
	if err != nil {
		return 0, err
	}

	return pluginID, nil
}

func (p *pluginRepoImpl) GetDraftPlugin(ctx context.Context, pluginID int64, opts ...PluginSelectedOptions) (plugin *entity.PluginInfo, exist bool, err error) {
	var opt *dal.PluginSelectedOption
	if len(opts) > 0 {
		opt = &dal.PluginSelectedOption{}
		for _, o := range opts {
			o(opt)
		}
	}

	return p.pluginDraftDAO.Get(ctx, pluginID, opt)
}

func (p *pluginRepoImpl) MGetDraftPlugins(ctx context.Context, pluginIDs []int64, opts ...PluginSelectedOptions) (plugins []*entity.PluginInfo, err error) {
	var opt *dal.PluginSelectedOption
	if len(opts) > 0 {
		opt = &dal.PluginSelectedOption{}
		for _, o := range opts {
			o(opt)
		}
	}

	return p.pluginDraftDAO.MGet(ctx, pluginIDs, opt)
}

func (p *pluginRepoImpl) GetAPPAllDraftPlugins(ctx context.Context, appID int64, opts ...PluginSelectedOptions) (plugins []*entity.PluginInfo, err error) {
	var opt *dal.PluginSelectedOption
	if len(opts) > 0 {
		opt = &dal.PluginSelectedOption{}
		for _, o := range opts {
			o(opt)
		}
	}

	return p.pluginDraftDAO.GetAPPAllPlugins(ctx, appID, opt)
}

func (p *pluginRepoImpl) ListDraftPlugins(ctx context.Context, req *ListDraftPluginsRequest) (resp *ListDraftPluginsResponse, err error) {
	plugins, total, err := p.pluginDraftDAO.List(ctx, req.SpaceID, req.APPID, req.PageInfo)
	if err != nil {
		return nil, err
	}

	resp = &ListDraftPluginsResponse{
		Plugins: plugins,
		Total:   total,
	}

	return resp, nil
}

func (p *pluginRepoImpl) UpdateDraftPlugin(ctx context.Context, plugin *entity.PluginInfo) (err error) {
	tx := p.query.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	err = p.pluginDraftDAO.UpdateWithTX(ctx, tx, plugin)
	if err != nil {
		return err
	}

	err = p.toolDraftDAO.ResetAllDebugStatusWithTX(ctx, tx, plugin.ID)
	if err != nil {
		return err
	}

	err = tx.Commit()
	if err != nil {
		return err
	}

	return nil
}

func (p *pluginRepoImpl) UpdateDraftPluginWithoutURLChanged(ctx context.Context, plugin *entity.PluginInfo) (err error) {
	return p.pluginDraftDAO.Update(ctx, plugin)
}

func (p *pluginRepoImpl) GetOnlinePlugin(ctx context.Context, pluginID int64, opts ...PluginSelectedOptions) (plugin *entity.PluginInfo, exist bool, err error) {
	pi, exist := pluginConf.GetPluginProduct(pluginID)
	if exist {
		return entity.NewPluginInfo(pi.Info), true, nil
	}

	var opt *dal.PluginSelectedOption
	if len(opts) > 0 {
		opt = &dal.PluginSelectedOption{}
		for _, o := range opts {
			o(opt)
		}
	}

	return p.pluginDAO.Get(ctx, pluginID, opt)
}

func (p *pluginRepoImpl) MGetOnlinePlugins(ctx context.Context, pluginIDs []int64, opts ...PluginSelectedOptions) (plugins []*entity.PluginInfo, err error) {
	pluginProducts := pluginConf.MGetPluginProducts(pluginIDs)
	plugins = slices.Transform(pluginProducts, func(pl *pluginConf.PluginInfo) *entity.PluginInfo {
		return entity.NewPluginInfo(pl.Info)
	})
	productPluginIDs := slices.ToMap(pluginProducts, func(plugin *pluginConf.PluginInfo) (int64, bool) {
		return plugin.Info.ID, true
	})

	customPluginIDs := make([]int64, 0, len(pluginIDs))
	for _, id := range pluginIDs {
		_, ok := productPluginIDs[id]
		if ok {
			continue
		}
		customPluginIDs = append(customPluginIDs, id)
	}

	var opt *dal.PluginSelectedOption
	if len(opts) > 0 {
		opt = &dal.PluginSelectedOption{}
		for _, o := range opts {
			o(opt)
		}
	}

	customPlugins, err := p.pluginDAO.MGet(ctx, customPluginIDs, opt)
	if err != nil {
		return nil, err
	}

	plugins = append(plugins, customPlugins...)

	return plugins, nil
}

func (p *pluginRepoImpl) ListCustomOnlinePlugins(ctx context.Context, spaceID int64, pageInfo entity.PageInfo) (plugins []*entity.PluginInfo, total int64, err error) {
	return p.pluginDAO.List(ctx, spaceID, pageInfo)
}

func (p *pluginRepoImpl) GetVersionPlugin(ctx context.Context, vPlugin entity.VersionPlugin) (plugin *entity.PluginInfo, exist bool, err error) {
	pi, exist := pluginConf.GetPluginProduct(vPlugin.PluginID)
	if exist {
		return entity.NewPluginInfo(pi.Info), true, nil
	}

	return p.pluginVersionDAO.Get(ctx, vPlugin.PluginID, vPlugin.Version)
}

func (p *pluginRepoImpl) MGetVersionPlugins(ctx context.Context, vPlugins []entity.VersionPlugin, opts ...PluginSelectedOptions) (plugins []*entity.PluginInfo, err error) {
	pluginIDs := make([]int64, 0, len(vPlugins))
	for _, vPlugin := range vPlugins {
		pluginIDs = append(pluginIDs, vPlugin.PluginID)
	}

	pluginProducts := pluginConf.MGetPluginProducts(pluginIDs)
	plugins = slices.Transform(pluginProducts, func(pl *pluginConf.PluginInfo) *entity.PluginInfo {
		return entity.NewPluginInfo(pl.Info)
	})
	productPluginIDs := slices.ToMap(pluginProducts, func(plugin *pluginConf.PluginInfo) (int64, bool) {
		return plugin.Info.ID, true
	})

	vCustomPlugins := make([]entity.VersionPlugin, 0, len(pluginIDs))
	for _, v := range vPlugins {
		_, ok := productPluginIDs[v.PluginID]
		if ok {
			continue
		}
		vCustomPlugins = append(vCustomPlugins, v)
	}

	var opt *dal.PluginSelectedOption
	if len(opts) > 0 {
		opt = &dal.PluginSelectedOption{}
		for _, o := range opts {
			o(opt)
		}
	}

	customPlugins, err := p.pluginVersionDAO.MGet(ctx, vCustomPlugins, opt)
	if err != nil {
		return nil, err
	}

	plugins = append(plugins, customPlugins...)

	return plugins, nil
}

func (p *pluginRepoImpl) PublishPlugin(ctx context.Context, draftPlugin *entity.PluginInfo) (err error) {
	draftTools, err := p.toolDraftDAO.GetAll(ctx, draftPlugin.ID, nil)
	if err != nil {
		return err
	}

	activatedTools := make([]*entity.ToolInfo, 0, len(draftTools))
	for _, tool := range draftTools {
		if tool.GetActivatedStatus() == model.DeactivateTool {
			continue
		}

		tool.Version = draftPlugin.Version

		activatedTools = append(activatedTools, tool)
	}

	if len(activatedTools) == 0 {
		return errorx.New(errno.ErrPluginToolsCheckFailed, errorx.KVf(errno.PluginMsgKey,
			"at least one activated tool is required in plugin '%s'", draftPlugin.GetName()))
	}

	tx := p.query.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	err = p.pluginDAO.UpsertWithTX(ctx, tx, draftPlugin)
	if err != nil {
		return err
	}

	err = p.pluginVersionDAO.CreateWithTX(ctx, tx, draftPlugin)
	if err != nil {
		return err
	}

	err = p.toolDAO.DeleteAllWithTX(ctx, tx, draftPlugin.ID)
	if err != nil {
		return err
	}

	err = p.toolDAO.BatchCreateWithTX(ctx, tx, activatedTools)
	if err != nil {
		return err
	}

	err = p.toolVersionDAO.BatchCreateWithTX(ctx, tx, activatedTools)
	if err != nil {
		return err
	}

	return tx.Commit()
}

func (p *pluginRepoImpl) PublishPlugins(ctx context.Context, draftPlugins []*entity.PluginInfo) (err error) {
	draftPluginMap := slices.ToMap(draftPlugins, func(plugin *entity.PluginInfo) (int64, *entity.PluginInfo) {
		return plugin.ID, plugin
	})

	pluginTools := make(map[int64][]*entity.ToolInfo, len(draftPlugins))
	for _, draftPlugin := range draftPlugins {
		draftTools, err := p.toolDraftDAO.GetAll(ctx, draftPlugin.ID, nil)
		if err != nil {
			return err
		}

		activatedTools := make([]*entity.ToolInfo, 0, len(draftTools))
		for _, tool := range draftTools {
			if tool.GetActivatedStatus() == model.DeactivateTool {
				continue
			}

			if tool.DebugStatus == nil ||
				*tool.DebugStatus == common.APIDebugStatus_DebugWaiting {
				return errorx.New(errno.ErrPluginToolsCheckFailed, errorx.KVf(errno.PluginMsgKey,
					"tool '%s' in plugin '%s' has not debugged yet", tool.GetName(), draftPlugin.GetName()))
			}

			tool.Version = draftPlugin.Version

			activatedTools = append(activatedTools, tool)
		}

		if len(activatedTools) == 0 {
			return errorx.New(errno.ErrPluginToolsCheckFailed, errorx.KVf(errno.PluginMsgKey,
				"at least one activated tool is required in plugin '%s'", draftPlugin.GetName()))
		}

		pluginTools[draftPlugin.ID] = activatedTools
	}

	tx := p.query.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	for pluginID, tools := range pluginTools {
		draftPlugin := draftPluginMap[pluginID]

		err = p.pluginDAO.UpsertWithTX(ctx, tx, draftPlugin)
		if err != nil {
			return err
		}

		err = p.pluginVersionDAO.CreateWithTX(ctx, tx, draftPlugin)
		if err != nil {
			return err
		}

		err = p.toolDAO.DeleteAllWithTX(ctx, tx, draftPlugin.ID)
		if err != nil {
			return err
		}

		err = p.toolDAO.BatchCreateWithTX(ctx, tx, tools)
		if err != nil {
			return err
		}

		err = p.toolVersionDAO.BatchCreateWithTX(ctx, tx, tools)
		if err != nil {
			return err
		}
	}

	return tx.Commit()
}

func (p *pluginRepoImpl) DeleteDraftPlugin(ctx context.Context, pluginID int64) (err error) {
	tx := p.query.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	err = p.pluginDraftDAO.DeleteWithTX(ctx, tx, pluginID)
	if err != nil {
		return err
	}
	err = p.pluginDAO.DeleteWithTX(ctx, tx, pluginID)
	if err != nil {
		return err
	}
	err = p.pluginVersionDAO.DeleteWithTX(ctx, tx, pluginID)
	if err != nil {
		return err
	}
	err = p.toolDraftDAO.DeleteAllWithTX(ctx, tx, pluginID)
	if err != nil {
		return err
	}
	err = p.toolDAO.DeleteAllWithTX(ctx, tx, pluginID)
	if err != nil {
		return err
	}
	err = p.toolVersionDAO.DeleteWithTX(ctx, tx, pluginID)
	if err != nil {
		return err
	}

	return tx.Commit()
}

func (p *pluginRepoImpl) DeleteAPPAllPlugins(ctx context.Context, appID int64) (pluginIDs []int64, err error) {
	opt := &dal.PluginSelectedOption{
		PluginID: true,
	}
	plugins, err := p.pluginDraftDAO.GetAPPAllPlugins(ctx, appID, opt)
	if err != nil {
		return nil, err
	}

	pluginIDs = slices.Transform(plugins, func(plugin *entity.PluginInfo) int64 {
		return plugin.ID
	})

	tx := p.query.Begin()
	if tx.Error != nil {
		return nil, tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	for _, id := range pluginIDs {
		err = p.pluginDraftDAO.DeleteWithTX(ctx, tx, id)
		if err != nil {
			return nil, err
		}
		err = p.pluginDAO.DeleteWithTX(ctx, tx, id)
		if err != nil {
			return nil, err
		}
		err = p.pluginVersionDAO.DeleteWithTX(ctx, tx, id)
		if err != nil {
			return nil, err
		}
		err = p.toolDraftDAO.DeleteAllWithTX(ctx, tx, id)
		if err != nil {
			return nil, err
		}
		err = p.toolDAO.DeleteAllWithTX(ctx, tx, id)
		if err != nil {
			return nil, err
		}
		err = p.toolVersionDAO.DeleteWithTX(ctx, tx, id)
		if err != nil {
			return nil, err
		}
	}

	err = tx.Commit()
	if err != nil {
		return nil, err
	}

	return pluginIDs, nil
}

func (p *pluginRepoImpl) UpdateDraftPluginWithCode(ctx context.Context, req *UpdatePluginDraftWithCode) (err error) {
	tx := p.query.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	newDoc := &model.Openapi3T{}
	err = copier.CopyWithOption(newDoc, req.OpenapiDoc, copier.Option{DeepCopy: true, IgnoreEmpty: true})
	if err != nil {
		return err
	}

	newDoc.Paths = openapi3.Paths{} // reset paths

	updatedPlugin := entity.NewPluginInfo(&model.PluginInfo{
		ID:         req.PluginID,
		ServerURL:  ptr.Of(req.OpenapiDoc.Servers[0].URL),
		Manifest:   req.Manifest,
		OpenapiDoc: req.OpenapiDoc,
	})
	err = p.pluginDraftDAO.UpdateWithTX(ctx, tx, updatedPlugin)
	if err != nil {
		return err
	}

	for _, tool := range req.UpdatedTools {
		err = p.toolDraftDAO.UpdateWithTX(ctx, tx, tool)
		if err != nil {
			return err
		}
	}

	if len(req.NewDraftTools) > 0 {
		_, err = p.toolDraftDAO.BatchCreateWithTX(ctx, tx, req.NewDraftTools)
		if err != nil {
			return err
		}
	}

	err = tx.Commit()
	if err != nil {
		return err
	}

	return nil
}

func (p *pluginRepoImpl) CreateDraftPluginWithCode(ctx context.Context, req *CreateDraftPluginWithCodeRequest) (resp *CreateDraftPluginWithCodeResponse, err error) {
	doc := req.OpenapiDoc
	mf := req.Manifest

	pluginType, _ := model.ToThriftPluginType(mf.API.Type)

	pl := entity.NewPluginInfo(&model.PluginInfo{
		PluginType:  pluginType,
		SpaceID:     req.SpaceID,
		DeveloperID: req.DeveloperID,
		APPID:       req.ProjectID,
		IconURI:     ptr.Of(mf.LogoURL),
		ServerURL:   ptr.Of(doc.Servers[0].URL),
		Manifest:    mf,
		OpenapiDoc:  doc,
	})

	tools := make([]*entity.ToolInfo, 0, len(doc.Paths))
	for subURL, pathItem := range doc.Paths {
		for method, op := range pathItem.Operations() {
			tools = append(tools, &entity.ToolInfo{
				ActivatedStatus: ptr.Of(model.ActivateTool),
				DebugStatus:     ptr.Of(common.APIDebugStatus_DebugWaiting),
				SubURL:          ptr.Of(subURL),
				Method:          ptr.Of(method),
				Operation:       model.NewOpenapi3Operation(op),
			})
		}
	}

	tx := p.query.Begin()
	if tx.Error != nil {
		return nil, tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	pluginID, err := p.pluginDraftDAO.CreateWithTX(ctx, tx, pl)
	if err != nil {
		return nil, err
	}

	pl.ID = pluginID

	for _, tool := range tools {
		tool.PluginID = pluginID
	}

	_, err = p.toolDraftDAO.BatchCreateWithTX(ctx, tx, tools)
	if err != nil {
		return nil, err
	}

	err = tx.Commit()
	if err != nil {
		return nil, err
	}

	return &CreateDraftPluginWithCodeResponse{
		Plugin: pl,
		Tools:  tools,
	}, nil
}

func (p *pluginRepoImpl) CopyPlugin(ctx context.Context, req *CopyPluginRequest) (plugin *entity.PluginInfo, tools []*entity.ToolInfo, err error) {
	tx := p.query.Begin()
	if tx.Error != nil {
		return nil, nil, tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	plugin, tools = req.Plugin, req.Tools

	newPluginID, err := p.pluginDraftDAO.CreateWithTX(ctx, tx, plugin)
	if err != nil {
		return nil, nil, err
	}

	plugin.ID = newPluginID
	for _, tool := range tools {
		tool.PluginID = newPluginID
	}

	toolIDs, err := p.toolDraftDAO.BatchCreateWithTX(ctx, tx, tools)
	if err != nil {
		return nil, nil, err
	}

	for i, tool := range tools {
		tool.ID = toolIDs[i]
	}

	if plugin.GetVersion() == "" {
		err = tx.Commit()
		if err != nil {
			return nil, nil, err
		}

		return plugin, tools, nil
	}

	// publish plugin
	filteredTools := make([]*entity.ToolInfo, 0, len(tools))
	for _, tool := range tools {
		if tool.GetActivatedStatus() == model.DeactivateTool ||
			tool.GetDebugStatus() == common.APIDebugStatus_DebugWaiting {
			continue
		}
		filteredTools = append(filteredTools, tool)
	}

	if len(filteredTools) == 0 {
		return nil, nil, fmt.Errorf("at least one activated tool is required in plugin '%d'", plugin.ID)
	}

	err = p.pluginDAO.UpsertWithTX(ctx, tx, plugin)
	if err != nil {
		return nil, nil, err
	}
	err = p.pluginVersionDAO.CreateWithTX(ctx, tx, plugin)
	if err != nil {
		return nil, nil, err
	}

	err = p.toolDAO.BatchCreateWithTX(ctx, tx, filteredTools)
	if err != nil {
		return nil, nil, err
	}
	err = p.toolVersionDAO.BatchCreateWithTX(ctx, tx, filteredTools)
	if err != nil {
		return nil, nil, err
	}

	err = tx.Commit()
	if err != nil {
		return nil, nil, err
	}

	return req.Plugin, req.Tools, nil
}

func (p *pluginRepoImpl) MoveAPPPluginToLibrary(ctx context.Context, draftPlugin *entity.PluginInfo,
	draftTools []*entity.ToolInfo) (err error) {

	tx := p.query.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	defer func() {
		if r := recover(); r != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
			err = fmt.Errorf("catch panic: %v\nstack=%s", r, string(debug.Stack()))
			return
		}
		if err != nil {
			if e := tx.Rollback(); e != nil {
				logs.CtxErrorf(ctx, "rollback failed, err=%v", e)
			}
		}
	}()

	err = p.pluginDraftDAO.UpdateWithTX(ctx, tx, draftPlugin)
	if err != nil {
		return err
	}

	err = p.pluginDAO.DeleteWithTX(ctx, tx, draftPlugin.ID)
	if err != nil {
		return err
	}
	err = p.pluginVersionDAO.DeleteWithTX(ctx, tx, draftPlugin.ID)
	if err != nil {
		return err
	}
	err = p.toolDAO.DeleteAllWithTX(ctx, tx, draftPlugin.ID)
	if err != nil {
		return err
	}
	err = p.toolVersionDAO.DeleteWithTX(ctx, tx, draftPlugin.ID)
	if err != nil {
		return err
	}

	// publish plugin
	err = p.pluginDAO.UpsertWithTX(ctx, tx, draftPlugin)
	if err != nil {
		return err
	}
	err = p.pluginVersionDAO.CreateWithTX(ctx, tx, draftPlugin)
	if err != nil {
		return err
	}
	err = p.toolDAO.BatchCreateWithTX(ctx, tx, draftTools)
	if err != nil {
		return err
	}
	err = p.toolVersionDAO.BatchCreateWithTX(ctx, tx, draftTools)
	if err != nil {
		return err
	}

	err = tx.Commit()
	if err != nil {
		return err
	}

	return nil
}

func (p *pluginRepoImpl) UpdateDebugExample(ctx context.Context, pluginID int64, openapiDoc *model.Openapi3T) (err error) {
	updatedPlugin := entity.NewPluginInfo(&model.PluginInfo{
		ID:         pluginID,
		OpenapiDoc: openapiDoc,
	})
	return p.pluginDraftDAO.Update(ctx, updatedPlugin)
}