package task

import (
	"context"
	"fmt"
	"strings"

	"edge-infra.dev/pkg/lib/logging"

	"github.com/google/go-github/v47/github"

	"edge-infra.dev/pkg/f8n/devinfra/jack/constants"
	guestservices "edge-infra.dev/pkg/f8n/devinfra/jack/guest_services"
	"edge-infra.dev/pkg/f8n/devinfra/jack/plugin"
)

func addKindToNewIssue(ctx context.Context, log logging.EdgeLogger, client plugin.GithubClientInterface, event github.IssuesEvent) error {
	hasKindLabel := false
	labels := event.GetIssue().Labels
	for _, label := range labels {
		_, isKind := validateKindCommand(label.GetName())
		if isKind {
			hasKindLabel = true
		}
	}
	// It hasKindLabel, exit
	if hasKindLabel {
		return nil
	}

	// check for a kind command in the issue body
	// if none add the triage label
	taskCommands := guestservices.GetSpecificCommandFromBody(event.Issue.GetBody(), "kind", false, false)
	if len(taskCommands) <= 0 {
		taskCommands = append(taskCommands, string(constants.Task))
	}

	// Validate the label, if not right label --> bounce
	tempCommand := taskCommands[0]
	kind, validKind := validateKindCommand(tempCommand)
	if !validKind {
		log.Info("command is not a valid KIND-LABEL")
		kind = string(constants.Task)
	}

	// if there is a kind cmd, validate
	// if the command is not valid add the triage label
	issueNumber := event.GetIssue().GetNumber()
	repo := event.GetRepo()
	repoName := repo.GetName()
	repoOwner := repo.GetOwner().GetLogin()

	// if the command is valid add the appropriate label to the issue
	labelBody := []string{}
	// takes in the first kind label that the user wants to add in even if they want to add in multiple
	// updates the labels
	labelBody = append(labelBody, kind)
	_, _, err := client.Issues().AddLabelsToIssue(ctx, repoOwner, repoName, issueNumber, labelBody)
	if err != nil {
		log.Error(err, "Task: Failed to update issue desc")
		return err
	}
	return nil
}

func addTaskLabel(ctx context.Context, log logging.EdgeLogger, client plugin.GithubClientInterface, event github.IssuesEvent) error {
	// Prevent double check
	if event.GetSender().GetType() == "Bot" {
		return nil
	}
	issueNumber := event.GetIssue().GetNumber()
	repo := event.GetRepo()
	repoName := repo.GetName()
	repoOwner := repo.GetOwner().GetLogin()

	// check if the new label is a kind / triage kind label if not bounce
	labelName, valid := validateKindCommand(event.Label.GetName())

	// If label is not a valid kind/ label or diff than "kind/task"
	// Exit --> Autobot rollout!
	if !valid || !strings.Contains(labelName, string(constants.Task)) {
		log.Info("not a valid KIND-LABEL ----> exiting removeTaskLabel")
		return nil
	}

	log.Info(fmt.Sprintf("%s is a valid KIND command", labelName))

	//remove old kind label
	labelNames := []string{}
	for _, label := range event.GetIssue().Labels {
		name := label.GetName()
		if strings.Contains(name, "kind/") && name != string(constants.Task) { //name == labelName ||
			log.Info(fmt.Sprintf("adding %s", name))
			labelNames = append(labelNames, name)
		}
	}

	// update labels with old kind label removed
	githubIssueBody := &github.IssueRequest{Labels: &labelNames}
	_, _, err := client.Issues().Edit(ctx, repoOwner, repoName, issueNumber, githubIssueBody)
	if err != nil {
		log.Error(err, "Task: Failed to update issue desc")
		return err
	}
	return nil
}

func removeTaskLabel(ctx context.Context, log logging.EdgeLogger, client plugin.GithubClientInterface, event github.IssuesEvent) error {
	issueNumber := event.GetIssue().GetNumber()
	repo := event.GetRepo()
	repoName := repo.GetName()
	repoOwner := repo.GetOwner().GetLogin()

	// bounce if the label isnt a valid kind and isnt the kind/epic label
	//labelName := event.Label.GetName()

	labelName, valid := validateKindCommand(event.Label.GetName())
	if !valid && labelName != string(constants.Task) {
		log.Info("not a valid size label exiting removelabel")
		return nil
	}
	log.Info("Removing previous KIND-LABEL")
	labelBody := createNewLabelBodyWithKind(event.GetIssue().Labels)

	err := updateIssueTaskLabels(ctx, client, labelBody, repoOwner, repoName, issueNumber)
	if err != nil {
		log.Error(err, "Task: Failed to update issue desc")
		return err
	}
	return nil
}

// update an issues labels (sets all labels)
func updateIssueTaskLabels(ctx context.Context, client plugin.GithubClientInterface, labels []string, repoOwner, repoName string, issueNumber int) error {
	githubIssueBody := &github.IssueRequest{Labels: &labels}
	_, _, err := client.Issues().Edit(ctx, repoOwner, repoName, issueNumber, githubIssueBody)
	if err != nil {
		return err
	}
	return nil
}

/*
func createNewLabelBodyNoKind(labels []*github.Label) []string {
	label := []string{}
	// Add all existing labels to new label slice and toggle kind/ Label
	for _, v := range labels {
		name := v.GetName()
		if !strings.Contains(name, "kind/") {
			label = append(label, name)
		}
	}
	return label
}
*/

func createNewLabelBodyWithKind(labels []*github.Label) []string {
	label := []string{}
	kindLabelString := string(constants.Task)

	// Add all existing labels to new label slice and toggle kind Label
	hasKindLabel := false
	for _, v := range labels {
		name := v.GetName()
		label = append(label, name)
		if strings.Contains(name, "kind/") {
			hasKindLabel = true
		}
	}

	// Add kind/task label if non detected
	if !hasKindLabel {
		label = append(label, kindLabelString)
	}
	return label
}