package handler

import (
	"context"
	"fmt"
	"log"
	"ticket-pimp/internal/controller"

	"github.com/bwmarrin/discordgo"
)

func (h *router) CreateRepoHandler(repoNameMinLength int) route {
	const (
		repoType    = "repo_type"
		projectRepo = "project_repo"
		buildRepo   = "build_repo"
		nameOption  = "repo_name"
	)

	return route{
		Command: discordgo.ApplicationCommand{
			Name:        "repo",
			Description: "Command for repository creation",
			Options: []*discordgo.ApplicationCommandOption{
				{
					Type:        discordgo.ApplicationCommandOptionString,
					Name:        repoType,
					Description: "The type of repo",
					Required:    true,
					Choices: []*discordgo.ApplicationCommandOptionChoice{
						{
							Name:  "Unity project repo",
							Value: projectRepo,
						},
						{
							Name:  "XCode build repo",
							Value: buildRepo,
						},
					},
				},
				{
					Type:        discordgo.ApplicationCommandOptionString,
					Name:        nameOption,
					Description: "Type the repository's name",
					Required:    false,
					MinLength:   &repoNameMinLength,
				},
			},
		},
		Handler: func(s *discordgo.Session, i *discordgo.InteractionCreate) {
			// Моментальный ответ для избежания столкновения с протуханием токена
			initialResponse := discordgo.InteractionResponse{
				Type: discordgo.InteractionResponseChannelMessageWithSource,
				Data: &discordgo.InteractionResponseData{
					Flags:   discordgo.MessageFlagsEphemeral,
					Content: "👩‍🍳 Cooking your query..",
				},
			}

			s.InteractionRespond(i.Interaction, &initialResponse)

			// Определение переменной для ответа
			var result string = "unexpected result"

			// Access options in the order provided by the user.
			options := i.ApplicationCommandData().Options

			// Or convert the slice into a map
			optionMap := make(map[string]*discordgo.ApplicationCommandInteractionDataOption, len(options))
			for _, opt := range options {
				optionMap[opt.Name] = opt
			}

			// Creating request:
			var req controller.GitRequest
			name, insertedValueNotNil := optionMap[nameOption]
			isBuild := optionMap[repoType]
			switch isBuild.StringValue() {
			case buildRepo:
				req.IsBuildGit = true
			case projectRepo:
				req.IsBuildGit = false
			}
			dchan, err := s.Channel(i.ChannelID)

			if err != nil {
				log.Printf("error while identifying channel: %v", err)
			} else {

				if dchan.ParentID == h.conf.IsProjectChannel {
					req.ChannelID = dchan.ID
					if insertedValueNotNil {
						req.InsertedName = name.StringValue()
					}
				} else {
					req.ChannelID = ""
					if insertedValueNotNil {
						req.InsertedName = name.StringValue()
					}
				}
			}

			// Making request:
			resp := h.controller.CreateGit(context.TODO(), req)
			if resp.Project == nil {
				result = resp.Message.Error()
			} else {
				result = fmt.Sprintf(
					"## Project info:\n🔑 key: %s\n📂 folder: %s\n👾 project git: %s\n🚀 build git: %s\n\nErrors: %v",
					resp.Project.ShortName,
					resp.Project.Cloud,
					resp.Project.ProjectGit,
					resp.Project.BuildGit,
					resp.Message,
				)
			}
			// Sending result:
			_, err = s.FollowupMessageCreate(i.Interaction, true, &discordgo.WebhookParams{
				Content: result,
			})

			if err != nil {
				s.FollowupMessageCreate(i.Interaction, true, &discordgo.WebhookParams{
					Content: fmt.Sprintf("Something went wrong: %v", err),
				})
				return
			}
		},
	}
}