pop/cmd/folders.go

package cmd

import (
	"fmt"
	"os"
	"text/tabwriter"

	"github.com/frenocorp/pop/internal/api"
	"github.com/frenocorp/pop/internal/auth"
	"github.com/frenocorp/pop/internal/config"
	"github.com/frenocorp/pop/internal/labels"
	"github.com/spf13/cobra"
)

func folderCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "folder",
		Short: "Manage folders",
		Long:  `List, create, update, and delete folders in ProtonMail.`,
	}

	cmd.AddCommand(folderListCmd())
	cmd.AddCommand(folderCreateCmd())
	cmd.AddCommand(folderUpdateCmd())
	cmd.AddCommand(folderDeleteCmd())

	return cmd
}

func labelCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "label",
		Short: "Manage labels",
		Long:  `List, create, update, delete labels and apply/remove them from messages.`,
	}

	cmd.AddCommand(labelListCmd())
	cmd.AddCommand(labelCreateCmd())
	cmd.AddCommand(labelUpdateCmd())
	cmd.AddCommand(labelDeleteCmd())
	cmd.AddCommand(labelApplyCmd())
	cmd.AddCommand(labelRemoveCmd())

	return cmd
}

// --- Folder Commands ---

func folderListCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "list",
		Short: "List folders",
		Long:  `List all folders in ProtonMail.`,
		RunE: func(cmd *cobra.Command, args []string) error {
			client, err := newLabelClient()
			if err != nil {
				return err
			}

			result, err := client.ListFolders()
			if err != nil {
				return fmt.Errorf("failed to list folders: %w", err)
			}

			return printFolders(result.Folders)
		},
	}
}

func folderCreateCmd() *cobra.Command {
	var name, parentID string

	cmd := &cobra.Command{
		Use:   "create <name>",
		Short: "Create a folder",
		Long:  `Create a new folder in ProtonMail.`,
		Args:  cobra.MaximumNArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			folderName := name
			if len(args) > 0 && args[0] != "" {
				folderName = args[0]
			}
			if folderName == "" {
				return fmt.Errorf("folder name is required")
			}

			client, err := newLabelClient()
			if err != nil {
				return err
			}

			req := labels.CreateFolderRequest{
				Name:     folderName,
				ParentID: parentID,
			}

			folder, err := client.CreateFolder(req)
			if err != nil {
				return fmt.Errorf("failed to create folder: %w", err)
			}

			fmt.Printf("Created folder: %s (ID: %s)\n", folder.Name, folder.ID)
			return nil
		},
	}

	cmd.Flags().StringVar(&name, "name", "", "Folder name (or pass as positional argument)")
	cmd.Flags().StringVar(&parentID, "parent", "", "Parent folder ID for nested folders")

	return cmd
}

func folderUpdateCmd() *cobra.Command {
	var newName string

	cmd := &cobra.Command{
		Use:   "update <folder-id>",
		Short: "Update a folder",
		Long:  `Update a folder's name.`,
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			folderID := args[0]
			if newName == "" {
				return fmt.Errorf("new name is required (--name)")
			}

			client, err := newLabelClient()
			if err != nil {
				return err
			}

			req := labels.UpdateFolderRequest{
				Name: newName,
			}

			folder, err := client.UpdateFolder(folderID, req)
			if err != nil {
				return fmt.Errorf("failed to update folder: %w", err)
			}

			fmt.Printf("Updated folder: %s (ID: %s)\n", folder.Name, folder.ID)
			return nil
		},
	}

	cmd.Flags().StringVar(&newName, "name", "", "New folder name")
	_ = cmd.MarkFlagRequired("name")

	return cmd
}

func folderDeleteCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "delete <folder-id>",
		Short: "Delete a folder",
		Long:  `Delete a folder from ProtonMail. This action cannot be undone.`,
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			folderID := args[0]

			client, err := newLabelClient()
			if err != nil {
				return err
			}

			if err := client.DeleteFolder(folderID); err != nil {
				return fmt.Errorf("failed to delete folder: %w", err)
			}

			fmt.Printf("Deleted folder: %s\n", folderID)
			return nil
		},
	}
}

// --- Label Commands ---

func labelListCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "list",
		Short: "List labels",
		Long:  `List all labels in ProtonMail.`,
		RunE: func(cmd *cobra.Command, args []string) error {
			client, err := newLabelClient()
			if err != nil {
				return err
			}

			result, err := client.ListLabels()
			if err != nil {
				return fmt.Errorf("failed to list labels: %w", err)
			}

			return printLabels(result.Labels)
		},
	}
}

func labelCreateCmd() *cobra.Command {
	var name, color string

	cmd := &cobra.Command{
		Use:   "create <name>",
		Short: "Create a label",
		Long:  `Create a new label in ProtonMail.`,
		Args:  cobra.MaximumNArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			labelName := name
			if len(args) > 0 && args[0] != "" {
				labelName = args[0]
			}
			if labelName == "" {
				return fmt.Errorf("label name is required")
			}

			client, err := newLabelClient()
			if err != nil {
				return err
			}

			req := labels.CreateLabelRequest{
				Name:  labelName,
				Color: color,
			}

			label, err := client.CreateLabel(req)
			if err != nil {
				return fmt.Errorf("failed to create label: %w", err)
			}

			fmt.Printf("Created label: %s (ID: %s)\n", label.Name, label.ID)
			return nil
		},
	}

	cmd.Flags().StringVar(&name, "name", "", "Label name (or pass as positional argument)")
	cmd.Flags().StringVar(&color, "color", "", "Label color (hex, e.g. #FF0000)")

	return cmd
}

func labelUpdateCmd() *cobra.Command {
	var newName, newColor string

	cmd := &cobra.Command{
		Use:   "update <label-id>",
		Short: "Update a label",
		Long:  `Update a label's name or color.`,
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			labelID := args[0]

			client, err := newLabelClient()
			if err != nil {
				return err
			}

			req := labels.UpdateLabelRequest{
				Name: newName,
			}
			if newColor != "" {
				req.Color = &newColor
			}

			label, err := client.UpdateLabel(labelID, req)
			if err != nil {
				return fmt.Errorf("failed to update label: %w", err)
			}

			fmt.Printf("Updated label: %s (ID: %s)\n", label.Name, label.ID)
			return nil
		},
	}

	cmd.Flags().StringVar(&newName, "name", "", "New label name")
	cmd.Flags().StringVar(&newColor, "color", "", "New label color (hex, e.g. #FF0000)")

	return cmd
}

func labelDeleteCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "delete <label-id>",
		Short: "Delete a label",
		Long:  `Delete a label from ProtonMail.`,
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			labelID := args[0]

			client, err := newLabelClient()
			if err != nil {
				return err
			}

			if err := client.DeleteLabel(labelID); err != nil {
				return fmt.Errorf("failed to delete label: %w", err)
			}

			fmt.Printf("Deleted label: %s\n", labelID)
			return nil
		},
	}
}

func labelApplyCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "apply <message-id> <label-id>",
		Short: "Apply a label to a message",
		Long:  `Apply a label to a message in ProtonMail.`,
		Args:  cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			messageID := args[0]
			labelID := args[1]

			client, err := newLabelClient()
			if err != nil {
				return err
			}

			if err := client.ApplyLabel(messageID, labelID); err != nil {
				return fmt.Errorf("failed to apply label: %w", err)
			}

			fmt.Printf("Applied label %s to message %s\n", labelID, messageID)
			return nil
		},
	}
}

func labelRemoveCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "remove <message-id> <label-id>",
		Short: "Remove a label from a message",
		Long:  `Remove a label from a message in ProtonMail.`,
		Args:  cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			messageID := args[0]
			labelID := args[1]

			client, err := newLabelClient()
			if err != nil {
				return err
			}

			if err := client.RemoveLabel(messageID, labelID); err != nil {
				return fmt.Errorf("failed to remove label: %w", err)
			}

			fmt.Printf("Removed label %s from message %s\n", labelID, messageID)
			return nil
		},
	}
}

// --- Helpers ---

func newLabelClient() (*labels.Client, error) {
	cfgMgr := config.NewConfigManager()
	cfg, err := cfgMgr.Load()
	if err != nil {
		return nil, fmt.Errorf("failed to load config: %w", err)
	}

	sessionMgr, err := auth.NewSessionManager()
	if err != nil {
		return nil, fmt.Errorf("failed to create session manager: %w", err)
	}
	session, err := sessionMgr.GetSession()
	if err != nil {
		return nil, fmt.Errorf("not authenticated: %w", err)
	}

	apiClient := api.NewProtonMailClient(cfg)
	apiClient.SetAuthHeader(session.AccessToken)

	return labels.NewClient(apiClient), nil
}

func printFolders(folders []labels.Folder) error {
	if len(folders) == 0 {
		fmt.Println("No folders found")
		return nil
	}

	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
	fmt.Fprintln(w, "ID\tName\tType\tMessages")
	fmt.Fprintln(w, "--\t----\t----\t--------")

	for _, f := range folders {
		fmt.Fprintf(w, "%s\t%s\t%d\t%d\n", f.ID, f.Name, f.Type, f.MessageCount)
	}

	return w.Flush()
}

func printLabels(labelsList []labels.Label) error {
	if len(labelsList) == 0 {
		fmt.Println("No labels found")
		return nil
	}

	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
	fmt.Fprintln(w, "ID\tName\tColor")
	fmt.Fprintln(w, "--\t----\t-----")

	for _, l := range labelsList {
		fmt.Fprintf(w, "%s\t%s\t%s\n", l.ID, l.Name, l.Color)
	}

	return w.Flush()
}