package record

import (
	"context"
	"fmt"
	"strconv"

	"coopcloud.tech/abra/cli/internal"
	gandiPkg "coopcloud.tech/abra/pkg/dns/gandi"
	"coopcloud.tech/abra/pkg/formatter"
	"github.com/AlecAivazis/survey/v2"
	"github.com/libdns/gandi"
	"github.com/libdns/libdns"
	"github.com/sirupsen/logrus"
	"github.com/urfave/cli"
)

// RecordRemoveCommand lists domains.
var RecordRemoveCommand = cli.Command{
	Name:      "remove",
	Usage:     "Remove a domain name record",
	Aliases:   []string{"rm"},
	ArgsUsage: "<zone>",
	Flags: []cli.Flag{
		internal.DebugFlag,
		internal.NoInputFlag,
		internal.DNSProviderFlag,
		internal.DNSTypeFlag,
		internal.DNSNameFlag,
	},
	Before: internal.SubCommandBefore,
	Description: `
This command removes a domain name record for a specific zone.

It uses the type of record and name to match existing records and choose one
for deletion. You must specify a zone (e.g. example.com) under which your
domain name records are listed. This zone must already be created on your
provider account.

Example:

    abra record remove foo.com -p gandi -t A -n myapp

You may also invoke this command in "wizard" mode and be prompted for input

    abra record rm
`,
	Action: func(c *cli.Context) error {
		zone, err := internal.EnsureZoneArgument(c)
		if err != nil {
			logrus.Fatal(err)
		}

		if err := internal.EnsureDNSProvider(); err != nil {
			logrus.Fatal(err)
		}

		var provider gandi.Provider
		switch internal.DNSProvider {
		case "gandi":
			provider, err = gandiPkg.New()
			if err != nil {
				logrus.Fatal(err)
			}
		default:
			logrus.Fatalf("%s is not a supported DNS provider", internal.DNSProvider)
		}

		if err := internal.EnsureDNSTypeFlag(c); err != nil {
			logrus.Fatal(err)
		}

		if err := internal.EnsureDNSNameFlag(c); err != nil {
			logrus.Fatal(err)
		}

		records, err := provider.GetRecords(context.Background(), zone)
		if err != nil {
			logrus.Fatal(err)
		}

		var toDelete libdns.Record
		for _, record := range records {
			if record.Type == internal.DNSType && record.Name == internal.DNSName {
				toDelete = record
				break
			}
		}

		if (libdns.Record{}) == toDelete {
			logrus.Fatal("provider library reports no matching record?")
		}

		tableCol := []string{"type", "name", "value", "TTL", "priority"}
		table := formatter.CreateTable(tableCol)

		value := toDelete.Value
		if len(toDelete.Value) > 30 {
			value = fmt.Sprintf("%s...", toDelete.Value[:30])
		}

		table.Append([]string{
			toDelete.Type,
			toDelete.Name,
			value,
			toDelete.TTL.String(),
			strconv.Itoa(toDelete.Priority),
		})

		table.Render()

		if !internal.NoInput {
			response := false
			prompt := &survey.Confirm{
				Message: "continue with record deletion?",
			}

			if err := survey.AskOne(prompt, &response); err != nil {
				return err
			}

			if !response {
				logrus.Fatal("exiting as requested")
			}
		}

		_, err = provider.DeleteRecords(context.Background(), zone, []libdns.Record{toDelete})
		if err != nil {
			logrus.Fatal(err)
		}

		logrus.Info("record successfully deleted")

		return nil
	},
}