package repo

import (
	"context"
	"errors"
	"fmt"

	"git.lethalbits.com/lethalbits/gitea-mcp/pkg/gitea"
	"git.lethalbits.com/lethalbits/gitea-mcp/pkg/log"
	"git.lethalbits.com/lethalbits/gitea-mcp/pkg/params"
	"git.lethalbits.com/lethalbits/gitea-mcp/pkg/to"

	gitea_sdk "code.gitea.io/sdk/gitea"
	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
)

const (
	ListCollaboratorsToolName      = "list_collaborators"
	IsCollaboratorToolName         = "is_collaborator"
	CollaboratorPermissionToolName = "collaborator_permission"
	AddCollaboratorToolName        = "add_collaborator"
	DeleteCollaboratorToolName     = "delete_collaborator"
	GetReviewersToolName           = "get_reviewers"
	GetAssigneesToolName           = "get_assignees"
)

var (
	ListCollaboratorsTool = mcp.NewTool(
		ListCollaboratorsToolName,
		mcp.WithDescription("List a repository's collaborators"),
		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
		mcp.WithNumber("page", mcp.Description("page number"), mcp.DefaultNumber(1)),
		mcp.WithNumber("pageSize", mcp.Description("page size"), mcp.DefaultNumber(100)),
	)

	IsCollaboratorTool = mcp.NewTool(
		IsCollaboratorToolName,
		mcp.WithDescription("Check if a user is a collaborator of a repository"),
		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
		mcp.WithString("collaborator", mcp.Required(), mcp.Description("username to check")),
	)

	CollaboratorPermissionTool = mcp.NewTool(
		CollaboratorPermissionToolName,
		mcp.WithDescription("Get a collaborator's permission level on a repository"),
		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
		mcp.WithString("collaborator", mcp.Required(), mcp.Description("collaborator username")),
	)

	AddCollaboratorTool = mcp.NewTool(
		AddCollaboratorToolName,
		mcp.WithDescription("Add a collaborator to a repository"),
		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
		mcp.WithString("collaborator", mcp.Required(), mcp.Description("username to add")),
		mcp.WithString("permission", mcp.Description("permission level: read, write, admin (default: write)")),
	)

	DeleteCollaboratorTool = mcp.NewTool(
		DeleteCollaboratorToolName,
		mcp.WithDescription("Remove a collaborator from a repository"),
		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
		mcp.WithString("collaborator", mcp.Required(), mcp.Description("username to remove")),
	)

	GetReviewersTool = mcp.NewTool(
		GetReviewersToolName,
		mcp.WithDescription("Get the list of users who can review PRs in a repository"),
		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
	)

	GetAssigneesTool = mcp.NewTool(
		GetAssigneesToolName,
		mcp.WithDescription("Get the list of users who can be assigned to issues in a repository"),
		mcp.WithString("owner", mcp.Required(), mcp.Description("repository owner")),
		mcp.WithString("repo", mcp.Required(), mcp.Description("repository name")),
	)
)

func init() {
	Tool.RegisterRead(server.ServerTool{Tool: ListCollaboratorsTool, Handler: ListCollaboratorsFn})
	Tool.RegisterRead(server.ServerTool{Tool: IsCollaboratorTool, Handler: IsCollaboratorFn})
	Tool.RegisterRead(server.ServerTool{Tool: CollaboratorPermissionTool, Handler: CollaboratorPermissionFn})
	Tool.RegisterRead(server.ServerTool{Tool: GetReviewersTool, Handler: GetReviewersFn})
	Tool.RegisterRead(server.ServerTool{Tool: GetAssigneesTool, Handler: GetAssigneesFn})
	Tool.RegisterWrite(server.ServerTool{Tool: AddCollaboratorTool, Handler: AddCollaboratorFn})
	Tool.RegisterWrite(server.ServerTool{Tool: DeleteCollaboratorTool, Handler: DeleteCollaboratorFn})
}

func ListCollaboratorsFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	log.Debugf("Called ListCollaboratorsFn")
	owner, _ := req.GetArguments()["owner"].(string)
	repo, _ := req.GetArguments()["repo"].(string)
	if owner == "" || repo == "" {
		return to.ErrorResult(errors.New("owner and repo are required"))
	}
	page := params.GetOptionalInt(req.GetArguments(), "page", 1)
	pageSize := params.GetOptionalInt(req.GetArguments(), "pageSize", 100)
	client, err := gitea.ClientFromContext(ctx)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
	}
	users, _, err := client.ListCollaborators(owner, repo, gitea_sdk.ListCollaboratorsOptions{
		ListOptions: gitea_sdk.ListOptions{Page: int(page), PageSize: int(pageSize)},
	})
	if err != nil {
		return to.ErrorResult(fmt.Errorf("list collaborators err: %v", err))
	}
	return to.TextResult(users)
}

func IsCollaboratorFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	log.Debugf("Called IsCollaboratorFn")
	owner, _ := req.GetArguments()["owner"].(string)
	repo, _ := req.GetArguments()["repo"].(string)
	collaborator, _ := req.GetArguments()["collaborator"].(string)
	if owner == "" || repo == "" || collaborator == "" {
		return to.ErrorResult(errors.New("owner, repo, and collaborator are required"))
	}
	client, err := gitea.ClientFromContext(ctx)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
	}
	isCollab, _, err := client.IsCollaborator(owner, repo, collaborator)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("check collaborator err: %v", err))
	}
	return to.TextResult(map[string]any{"collaborator": collaborator, "is_collaborator": isCollab})
}

func CollaboratorPermissionFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	log.Debugf("Called CollaboratorPermissionFn")
	owner, _ := req.GetArguments()["owner"].(string)
	repo, _ := req.GetArguments()["repo"].(string)
	collaborator, _ := req.GetArguments()["collaborator"].(string)
	if owner == "" || repo == "" || collaborator == "" {
		return to.ErrorResult(errors.New("owner, repo, and collaborator are required"))
	}
	client, err := gitea.ClientFromContext(ctx)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
	}
	perm, _, err := client.CollaboratorPermission(owner, repo, collaborator)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get collaborator permission err: %v", err))
	}
	return to.TextResult(perm)
}

func AddCollaboratorFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	log.Debugf("Called AddCollaboratorFn")
	owner, _ := req.GetArguments()["owner"].(string)
	repo, _ := req.GetArguments()["repo"].(string)
	collaborator, _ := req.GetArguments()["collaborator"].(string)
	if owner == "" || repo == "" || collaborator == "" {
		return to.ErrorResult(errors.New("owner, repo, and collaborator are required"))
	}
	opt := gitea_sdk.AddCollaboratorOption{}
	if v, ok := req.GetArguments()["permission"].(string); ok {
		perm := gitea_sdk.AccessMode(v)
		opt.Permission = &perm
	}
	client, err := gitea.ClientFromContext(ctx)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
	}
	_, err = client.AddCollaborator(owner, repo, collaborator, opt)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("add collaborator err: %v", err))
	}
	return to.TextResult(map[string]string{"status": "added", "collaborator": collaborator})
}

func DeleteCollaboratorFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	log.Debugf("Called DeleteCollaboratorFn")
	owner, _ := req.GetArguments()["owner"].(string)
	repo, _ := req.GetArguments()["repo"].(string)
	collaborator, _ := req.GetArguments()["collaborator"].(string)
	if owner == "" || repo == "" || collaborator == "" {
		return to.ErrorResult(errors.New("owner, repo, and collaborator are required"))
	}
	client, err := gitea.ClientFromContext(ctx)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
	}
	_, err = client.DeleteCollaborator(owner, repo, collaborator)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("delete collaborator err: %v", err))
	}
	return to.TextResult(map[string]string{"status": "removed", "collaborator": collaborator})
}

func GetReviewersFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	log.Debugf("Called GetReviewersFn")
	owner, _ := req.GetArguments()["owner"].(string)
	repo, _ := req.GetArguments()["repo"].(string)
	if owner == "" || repo == "" {
		return to.ErrorResult(errors.New("owner and repo are required"))
	}
	client, err := gitea.ClientFromContext(ctx)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
	}
	users, _, err := client.GetReviewers(owner, repo)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get reviewers err: %v", err))
	}
	return to.TextResult(users)
}

func GetAssigneesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	log.Debugf("Called GetAssigneesFn")
	owner, _ := req.GetArguments()["owner"].(string)
	repo, _ := req.GetArguments()["repo"].(string)
	if owner == "" || repo == "" {
		return to.ErrorResult(errors.New("owner and repo are required"))
	}
	client, err := gitea.ClientFromContext(ctx)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
	}
	users, _, err := client.GetAssignees(owner, repo)
	if err != nil {
		return to.ErrorResult(fmt.Errorf("get assignees err: %v", err))
	}
	return to.TextResult(users)
}