package queues

import (
	"fmt"
	"strings"
	"xcecli/common/output"
	"xcecli/common/request"
	"xcecli/config"
	logger "xcecli/config"
	queue_filter "xcecli/filters"

	"xcecli/models"

	"github.com/spf13/cobra"
	"go.uber.org/zap"
)

var (
	user   string
	queue  string
	fields string
)

type QueuesQuerier struct {
	configManager *config.ConfigManager
	filter        *queue_filter.QueuesFilter
	fields        string
	jsonOutput    bool
	noHeader      bool
	verbose       bool
	wideFormat    bool // wide format
}

func NewQueuesQuerier(configManager *config.ConfigManager) *QueuesQuerier {
	return &QueuesQuerier{
		configManager: configManager,
		filter:        &queue_filter.QueuesFilter{},
	}
}

// Parse parses command line arguments, simplified version that doesn't need to process flags already bound to filter
func (qq *QueuesQuerier) ParseCmdArgs(cmd *cobra.Command, args []string) error {
	// No additional processing needed, all parameters are bound in flags
	if len(args) > 0 {
		qq.filter.QueueName = strings.Join(args, ",")
	}

	// Define mutual exclusions for verbose flag
	if qq.verbose {
		conflicts := make([]string, 0)

		if qq.wideFormat {
			conflicts = append(conflicts, "--wided (-w)")
		}

		if qq.fields != "" {
			conflicts = append(conflicts, "--output (-o)")
		}

		if len(conflicts) > 0 {
			return fmt.Errorf("flag --verbose (-l) cannot be used with: %s\n\n%s",
				strings.Join(conflicts, ", "), cmd.UsageString())
		}
	}
	return nil
}

func NewListQueuesCmd(configManager *config.ConfigManager) *cobra.Command {
	queuesQuerier := NewQueuesQuerier(configManager)

	cmd := &cobra.Command{
		Use:   "list",
		Short: "Query queue info",
		Long: `Query queue info, support filter by queue.
example:
  xce queues list                           # query all queues
  xce queues list -l                        # query all queues with detail
  xce queues list -w                        # list queues with wide format`,

		RunE: func(cmd *cobra.Command, args []string) error {
			if err := queuesQuerier.ParseCmdArgs(cmd, args); err != nil {
				fmt.Println(strings.ToLower(err.Error()))
				return nil
			}
			if err := queuesQuerier.RunQueuesList(); err != nil {
				fmt.Println(strings.ToLower(err.Error()))
				return nil
			}
			return nil
		},
	}

	// Add command line parameters
	flags := cmd.Flags()
	flags.StringVarP(&user, "user", "u", "", "filter by user")
	flags.StringVarP(&queuesQuerier.filter.QueueName, "queue", "q", "", "filter by queue name")
	flags.StringVarP(&queuesQuerier.fields, "output", "o", "", "output fields for queues")
	flags.BoolVarP(&queuesQuerier.wideFormat, "wided", "w", false, "output in wide format")
	flags.BoolVarP(&queuesQuerier.verbose, "verbose", "l", false, "show queue detail")
	flags.BoolVarP(&queuesQuerier.jsonOutput, "json", "", false, "output in JSON format")
	flags.BoolVarP(&queuesQuerier.noHeader, "noheader", "n", false, "output no header")
	return cmd
}

func (qq *QueuesQuerier) RunQueuesList() error {
	// Get configuration

	// Get server information
	serverInfo, _ := qq.configManager.GetServerInfo()
	// create API client
	apiClient := request.NewAPIClient(serverInfo.URL)
	apiClient.SetRootCAs(serverInfo.CACert)

	// Create query parameters
	params := make(map[string]string)

	// Get filter string
	filterStr, err := qq.filter.HandleQueueFilter()

	if err != nil {
		errMsg := request.ExtractErrorMessage(err)
		return fmt.Errorf("failed to get filter: [%s]", errMsg)
	} else if filterStr != "" {
		params["filter"] = filterStr
	}

	// Field mapping
	fieldsMap := models.QueueFieldsMap

	if qq.verbose && qq.fields == "" {
		for header := range fieldsMap {
			qq.fields += header + ","
		}
		qq.fields = strings.TrimSuffix(qq.fields, ",")
	}
	// Process field selection
	if qq.fields != "" {
		qq.fields = request.CleanFields(qq.fields)
		mappedFields, err := request.CheckAndMapFields(qq.fields, fieldsMap)
		if err != nil {
			return err
		}
		params["fields"] = strings.Join(mappedFields, ",")
	}

	// create page printer
	pagePrinter := output.NewPagePrinter(output.DataTypeQueues, output.WithFields(qq.fields),
		output.WithFormatJson(qq.jsonOutput), output.WithNoHeader(qq.noHeader),
		output.WithVerbose(qq.verbose), output.WithWideFormat(qq.wideFormat))

	// Record if the first page has been processed
	isFirstPage := true

	var (
		resp      models.QueuesResponse
		loopCount int
		pageToken string
	)

	// Loop to get all pages of data
	for {
		if loopCount > 0 && pageToken == "" {
			break
		}

		err = apiClient.GetRequestFromAPIServer(serverInfo.Token, pageToken, serverInfo.CACert, "/xce/v1/queues", &resp, params)
		if err != nil {
			return err
		}

		if len(resp.Data.Rows) == 0 {
			if isFirstPage {
				fmt.Println("no queue found")
				return nil
			}
			//
		}
		// Process the first page
		if isFirstPage {
			// Start printing process
			pagePrinter.StartPrinting()
			// Prepare for printing, calculate column width and table header, etc.
			pagePrinter.PrepareForPrinting(&resp)
			isFirstPage = false
		}
		// Print the current page
		pagePrinter.PrintPage(&resp)

		// Update page token and loop counter
		pageToken = resp.Data.Page_token
		loopCount++
	}

	// Finish printing
	pagePrinter.Finish()

	logger.Debug("queues response completed", zap.Int("pages", loopCount))
	return nil
}