main.go

package main

import (
	"fmt"
	"os"

	"github.com/spf13/cobra"

	"headview/network"
	"headview/output"
)

const appVersion = "1.1.19"

var (
	headersFlag    bool
	sizeFlag       bool
	concurrentFlag int
	jsonFlag       bool
	csvFlag        bool
)

func main() {
	var rootCmd = &cobra.Command{
		Use:   "headview <URL>",
		Short: "HTTP request timing analyzer",
		Long: `headview is a command-line tool for analyzing HTTP request performance.
It performs HEAD requests and provides detailed timing information for each
step of the connection process, including DNS lookup, TCP connection,
TLS handshake, and server response times.`,
		Args:    cobra.ExactArgs(1),
		RunE:    runHeadview,
		Example: `  headview https://example.com
  headview https://example.com --headers
  headview https://example.com --size --concurrent 10
  headview https://example.com --json`,
		Version: appVersion,
	}

	// Define flags (long flags only, no short flags for custom flags)
	rootCmd.Flags().BoolVar(&headersFlag, "headers", false, "Print response headers")
	rootCmd.Flags().BoolVar(&sizeFlag, "size", false, "Calculate size of page resources")
	rootCmd.Flags().IntVar(&concurrentFlag, "concurrent", 5, "Maximum concurrent requests for size calculation")
	rootCmd.Flags().BoolVar(&jsonFlag, "json", false, "Output in JSON format")
	rootCmd.Flags().BoolVar(&csvFlag, "csv", false, "Output in CSV format")

	if err := rootCmd.Execute(); err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}
}

func runHeadview(cmd *cobra.Command, args []string) error {
	urlArg := args[0]

	// Validate URL
	if urlArg == "" {
		return fmt.Errorf("URL cannot be empty")
	}

	urlArg = network.AddDefaultProtocol(urlArg)

	// Check for conflicting output formats
	if jsonFlag && csvFlag {
		return fmt.Errorf("cannot use both --json and --csv flags")
	}

	// Validate concurrent parameter
	if concurrentFlag < 1 || concurrentFlag > 100 {
		return fmt.Errorf("concurrent must be between 1 and 100, got %d", concurrentFlag)
	}

	client := network.CreateHTTPClient()

	if sizeFlag {
		resources, err := network.PerformGetSize(client, urlArg, concurrentFlag)
		if err != nil {
			return fmt.Errorf("calculating size: %w", err)
		}

		if jsonFlag {
			output.PrintResourceSizesJSON(resources)
		} else if csvFlag {
			output.PrintResourceSizesCSV(resources)
		} else {
			output.PrintResourceSizes(resources)
		}
	} else {
		timeStats, responses, err := network.PerformGetRequest(client, urlArg, headersFlag)
		if err != nil {
			return fmt.Errorf("performing request: %w", err)
		}

		if jsonFlag {
			output.PrintTimingStatsJSON(timeStats, responses, headersFlag)
		} else if csvFlag {
			output.PrintTimingStatsCSV(timeStats, responses)
		} else {
			// Print combined response info and connection timings for each request
			for i, resp := range responses {
				// Print response info
				output.PrintResponseInfo(resp, timeStats.CommonTimings[i].DNSLookupTime > 0, headersFlag)

				// Print connection timing for this specific request
				if i < len(timeStats.CommonTimings) {
					output.PrintConnectionTiming(i+1, timeStats.CommonTimings[i])
				}
			}

			// Only print combined timing stats at the end
			output.PrintCombinedTimingStats(timeStats)
		}
	}

	return nil
}