package cmd

import (
	"fmt"
	"strconv"

	"git.db.org.ai/dborg/internal/client"
	"git.db.org.ai/dborg/internal/formatter"
	"git.db.org.ai/dborg/internal/models"
	"github.com/spf13/cobra"
)

var adminCmd = &cobra.Command{
	Use:   "admin",
	Short: "Admin operations",
	Long:  `Administrative operations for managing accounts`,
}

var adminListCmd = &cobra.Command{
	Use:   "list",
	Short: "List all accounts",
	RunE:  runAdminList,
}

var adminCreateCmd = &cobra.Command{
	Use:   "create [name]",
	Short: "Create new account",
	Args:  cobra.ExactArgs(1),
	RunE:  runAdminCreate,
}

var adminDeleteCmd = &cobra.Command{
	Use:   "delete [api_key]",
	Short: "Delete account",
	Args:  cobra.ExactArgs(1),
	RunE:  runAdminDelete,
}

var adminCreditsCmd = &cobra.Command{
	Use:   "credits [api_key] [amount]",
	Short: "Add credits to account",
	Args:  cobra.ExactArgs(2),
	RunE:  runAdminCredits,
}

var adminSetCreditsCmd = &cobra.Command{
	Use:   "set-credits [api_key] [amount]",
	Short: "Set account credits to specific amount",
	Args:  cobra.ExactArgs(2),
	RunE:  runAdminSetCredits,
}

var adminDisableCmd = &cobra.Command{
	Use:   "disable [api_key]",
	Short: "Disable/enable account",
	Args:  cobra.ExactArgs(1),
	RunE:  runAdminDisable,
}

var adminStatsCmd = &cobra.Command{
	Use:   "stats",
	Short: "Get account information and usage statistics",
	RunE:  runAdminStats,
}

var adminEditCmd = &cobra.Command{
	Use:   "edit [api_key]",
	Short: "Edit account properties",
	Args:  cobra.ExactArgs(1),
	RunE:  runAdminEdit,
}

func init() {
	rootCmd.AddCommand(adminCmd)
	adminCmd.AddCommand(adminListCmd)
	adminCmd.AddCommand(adminCreateCmd)
	adminCmd.AddCommand(adminDeleteCmd)
	adminCmd.AddCommand(adminCreditsCmd)
	adminCmd.AddCommand(adminSetCreditsCmd)
	adminCmd.AddCommand(adminDisableCmd)
	adminCmd.AddCommand(adminStatsCmd)
	adminCmd.AddCommand(adminEditCmd)

	adminCreateCmd.Flags().IntP("credits", "c", 0, "Initial credits")
	adminCreateCmd.Flags().BoolP("unlimited", "u", false, "Unlimited credits")
	adminCreateCmd.Flags().BoolP("premium", "p", false, "Premium account (enables skiptrace access)")
	adminDisableCmd.Flags().BoolP("enable", "e", false, "Enable account instead of disable")

	adminEditCmd.Flags().StringP("name", "n", "", "Update account name")
	adminEditCmd.Flags().IntP("credits", "c", -1, "Set credits amount")
	adminEditCmd.Flags().BoolP("unlimited", "u", false, "Set unlimited credits")
	adminEditCmd.Flags().BoolP("no-unlimited", "", false, "Remove unlimited credits")
	adminEditCmd.Flags().BoolP("premium", "p", false, "Set premium account")
	adminEditCmd.Flags().BoolP("no-premium", "", false, "Remove premium account")
	adminEditCmd.Flags().Bool("disable", false, "Disable account")
	adminEditCmd.Flags().BoolP("enable", "e", false, "Enable account")
}

func getAdminClient(cmd *cobra.Command) (*client.Client, error) {
	return newClient()
}

func runAdminList(cmd *cobra.Command, args []string) error {
	c, err := getAdminClient(cmd)
	if err != nil {
		return err
	}

	response, err := c.ListAccounts()
	if err != nil {
		return err
	}

	if err := checkError(response.Error); err != nil {
		return err
	}

	output, err := formatter.FormatAccountList(response.Accounts, IsJSONOutput())
	if err != nil {
		return err
	}

	printOutput(output)
	return nil
}

func runAdminCreate(cmd *cobra.Command, args []string) error {
	c, err := getAdminClient(cmd)
	if err != nil {
		return err
	}

	credits, _ := cmd.Flags().GetInt("credits")
	unlimited, _ := cmd.Flags().GetBool("unlimited")
	premium, _ := cmd.Flags().GetBool("premium")

	req := &models.AccountCreateRequest{
		Name:      args[0],
		Credits:   credits,
		Unlimited: unlimited,
		IsPremium: premium,
	}

	response, err := c.CreateAccount(req)
	if err != nil {
		return err
	}

	if err := checkError(response.Error); err != nil {
		return err
	}

	output, err := formatter.FormatAccountCreated(response.Account, response.Message, IsJSONOutput())
	if err != nil {
		return err
	}

	printOutput(output)
	return nil
}

func runAdminDelete(cmd *cobra.Command, args []string) error {
	c, err := getAdminClient(cmd)
	if err != nil {
		return err
	}

	response, err := c.DeleteAccount(args[0])
	if err != nil {
		return err
	}

	if err := checkError(response.Error); err != nil {
		return err
	}

	output, err := formatter.FormatAccountDeleted(response.Message, IsJSONOutput())
	if err != nil {
		return err
	}

	printOutput(output)
	return nil
}

func runAdminCredits(cmd *cobra.Command, args []string) error {
	c, err := getAdminClient(cmd)
	if err != nil {
		return err
	}

	credits, err := strconv.Atoi(args[1])
	if err != nil {
		return fmt.Errorf("invalid credits amount: %s", args[1])
	}

	response, err := c.UpdateCredits(args[0], credits)
	if err != nil {
		return err
	}

	if err := checkError(response.Error); err != nil {
		return err
	}

	output, err := formatter.FormatCreditsUpdated(response.Message, nil, IsJSONOutput())
	if err != nil {
		return err
	}

	printOutput(output)
	return nil
}

func runAdminSetCredits(cmd *cobra.Command, args []string) error {
	c, err := getAdminClient(cmd)
	if err != nil {
		return err
	}

	credits, err := strconv.Atoi(args[1])
	if err != nil {
		return fmt.Errorf("invalid credits amount: %s", args[1])
	}

	response, err := c.SetCredits(args[0], credits)
	if err != nil {
		return err
	}

	if err := checkError(response.Error); err != nil {
		return err
	}

	output, err := formatter.FormatCreditsUpdated(response.Message, response.Account, IsJSONOutput())
	if err != nil {
		return err
	}

	printOutput(output)
	return nil
}

func runAdminDisable(cmd *cobra.Command, args []string) error {
	c, err := getAdminClient(cmd)
	if err != nil {
		return err
	}

	enable, _ := cmd.Flags().GetBool("enable")
	response, err := c.ToggleAccount(args[0], enable)
	if err != nil {
		return err
	}

	if err := checkError(response.Error); err != nil {
		return err
	}

	output, err := formatter.FormatAccountToggled(response.Message, IsJSONOutput())
	if err != nil {
		return err
	}

	printOutput(output)
	return nil
}

func runAdminStats(cmd *cobra.Command, args []string) error {
	c, err := getAdminClient(cmd)
	if err != nil {
		return err
	}

	response, err := c.GetAccountStats()
	if err != nil {
		return err
	}

	if err := checkError(response.Error); err != nil {
		return err
	}

	output, err := formatter.FormatAccountStats(response, IsJSONOutput())
	if err != nil {
		return err
	}

	printOutput(output)
	return nil
}

func runAdminEdit(cmd *cobra.Command, args []string) error {
	c, err := getAdminClient(cmd)
	if err != nil {
		return err
	}

	req := &models.AccountUpdateRequest{}

	name, _ := cmd.Flags().GetString("name")
	if name != "" {
		req.Name = &name
	}

	credits, _ := cmd.Flags().GetInt("credits")
	if credits >= 0 {
		req.Credits = &credits
	}

	unlimited, _ := cmd.Flags().GetBool("unlimited")
	if unlimited {
		req.Unlimited = &unlimited
	}

	noUnlimited, _ := cmd.Flags().GetBool("no-unlimited")
	if noUnlimited {
		req.Unlimited = &noUnlimited
	}

	premium, _ := cmd.Flags().GetBool("premium")
	if premium {
		req.IsPremium = &premium
	}

	noPremium, _ := cmd.Flags().GetBool("no-premium")
	if noPremium {
		req.IsPremium = &noPremium
	}

	disable, _ := cmd.Flags().GetBool("disable")
	if disable {
		req.Disabled = &disable
	}

	enable, _ := cmd.Flags().GetBool("enable")
	if enable {
		falseVal := false
		req.Disabled = &falseVal
	}

	if req.Name == nil && req.Credits == nil && req.Unlimited == nil &&
		req.IsPremium == nil && req.Disabled == nil {
		return fmt.Errorf("no changes specified — use --name, --credits, --unlimited, --no-unlimited, --premium, --no-premium, --disable, or --enable")
	}

	response, err := c.UpdateAccount(args[0], req)
	if err != nil {
		return err
	}

	if err := checkError(response.Error); err != nil {
		return err
	}

	output, err := formatter.FormatAccountUpdated(response.Account, response.Message, IsJSONOutput())
	if err != nil {
		return err
	}

	printOutput(output)
	return nil
}