main.go

package main

import (
	"bufio"
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"math/rand"
	"net/http"
	"os"
	"os/signal"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"time"
)

// headerFlag permite passar -H "Key: Value" repetidas vezes
type headerFlag []string

func (h *headerFlag) String() string { return strings.Join(*h, ", ") }
func (h *headerFlag) Set(value string) error {
	*h = append(*h, value)
	return nil
}

// RequestLogEntry representa uma entrada de log para cada request
type RequestLogEntry struct {
	Timestamp      string                 `json:"timestamp"`
	RequestNum     int                    `json:"request_num"`
	URL            string                 `json:"url"`
	Method         string                 `json:"method"`
	StatusCode     int                    `json:"status_code,omitempty"`
	ResponseTimeMs int64                  `json:"response_time_ms"`
	ResponseBytes  int                    `json:"response_bytes,omitempty"`
	Success        bool                   `json:"success"`
	Error          string                 `json:"error,omitempty"`
	RequestBody    string                 `json:"request_body,omitempty"`
	ResponseBody   string                 `json:"response_body,omitempty"`
	Variables      map[string]string      `json:"variables,omitempty"`
}

// Logger ultra-performático com canal e worker dedicado
type RequestLogger struct {
	file     *os.File
	logChan  chan RequestLogEntry
	done     chan struct{}
	buffer   *bufio.Writer
	encoder  *json.Encoder
}

// Pool de strings.Builder para reutilização e redução de alocações
var stringBuilderPool = sync.Pool{
	New: func() any {
		return &strings.Builder{}
	},
}

// getBuilder obtém um Builder do pool
func getBuilder() *strings.Builder {
	sb := stringBuilderPool.Get().(*strings.Builder)
	sb.Reset()
	return sb
}

// putBuilder devolve o Builder ao pool
func putBuilder(sb *strings.Builder) {
	stringBuilderPool.Put(sb)
}

// NewRequestLogger cria um novo logger com arquivo timestampado e worker dedicado
func NewRequestLogger() (*RequestLogger, error) {
	timestamp := time.Now().Format("20060102_150405")
	filename := fmt.Sprintf("%s.log", timestamp)

	file, err := os.Create(filename)
	if err != nil {
		return nil, fmt.Errorf("erro ao criar arquivo de log: %w", err)
	}

	buffer := bufio.NewWriterSize(file, 256*1024) // buffer de 256KB
	encoder := json.NewEncoder(buffer)

	logger := &RequestLogger{
		file:    file,
		logChan: make(chan RequestLogEntry, 10000), // buffer de 10k requests
		done:    make(chan struct{}),
		buffer:  buffer,
		encoder: encoder,
	}

	// iniciar worker dedicado para escrita
	go logger.logWorker()

	return logger, nil
}

// logWorker processa logs de forma assíncrona em uma única goroutine
func (l *RequestLogger) logWorker() {
	ticker := time.NewTicker(100 * time.Millisecond)
	defer ticker.Stop()

	for {
		select {
		case entry := <-l.logChan:
			// escrever no encoder (já serializa para JSON)
			l.encoder.Encode(entry)

		case <-ticker.C:
			// flush periódico para garantir que os dados sejam escritos
			l.buffer.Flush()

		case <-l.done:
			// processar logs pendentes antes de fechar
			for {
				select {
				case entry := <-l.logChan:
					l.encoder.Encode(entry)
				default:
					l.buffer.Flush()
					return
				}
			}
		}
	}
}

// LogAsync envia uma entrada de log para o canal (não-bloqueante, extremamente rápido)
func (l *RequestLogger) LogAsync(entry RequestLogEntry) {
	// copiar entry para evitar race conditions
	entryCopy := RequestLogEntry{
		Timestamp:      entry.Timestamp,
		RequestNum:     entry.RequestNum,
		URL:            entry.URL,
		Method:         entry.Method,
		StatusCode:     entry.StatusCode,
		ResponseTimeMs: entry.ResponseTimeMs,
		ResponseBytes:  entry.ResponseBytes,
		Success:        entry.Success,
		Error:          entry.Error,
		RequestBody:    entry.RequestBody,
		ResponseBody:   entry.ResponseBody,
		Variables:      make(map[string]string),
	}

	// copiar mapa de variáveis
	for k, v := range entry.Variables {
		entryCopy.Variables[k] = v
	}

	// enviar para canal (não bloqueia se canal estiver cheio)
	select {
	case l.logChan <- entryCopy:
	default:
		// canal cheio, descarta (em alta performance, melhor perder um log que travar)
	}
}

// PendingLogs retorna o número aproximado de logs pendentes no canal
func (l *RequestLogger) PendingLogs() int {
	return len(l.logChan)
}

// Close fecha o logger de forma graceful
func (l *RequestLogger) Close() error {
	close(l.done)          // sinaliza para worker parar
	time.Sleep(200 * time.Millisecond) // aguarda worker processar logs pendentes
	close(l.logChan)       // fecha o canal

	if err := l.buffer.Flush(); err != nil {
		return err
	}
	return l.file.Close()
}

func main() {
	var (
		concurrency  = flag.Int("c", 50, "number of concurrent workers")
		durationStr  = flag.String("d", "10s", "test duration (e.g. 30s, 1m)")
		timeout      = flag.Duration("t", 5*time.Second, "per-request timeout")
		method       = flag.String("m", "GET", "HTTP method to use")
		headers      headerFlag
		fillMode     = flag.Bool("fill", false, "interactive placeholder fill mode: read request from stdin and substitute [[var]] tokens")
		fillFile     = flag.String("f", "", "file to read request from (optional, reads from stdin if not specified)")
		fillWorkers  = flag.Int("w", 50, "number of concurrent workers in fill mode (default: 50)")
		perfMode     = flag.Bool("P", false, "performance mode: no logging, discard responses (maximum speed)")
	)
	flag.Var(&headers, "H", "header to add to request, can be repeated: -H 'Authorization: Bearer x' -H 'Accept: application/json'")
	flag.Usage = func() {
		fmt.Fprintf(flag.CommandLine.Output(), "Usage: %s [flags] <url>\n", os.Args[0])
		flag.PrintDefaults()
	}
	flag.Parse()

	if *fillMode {
		runInteractiveFill(*fillFile, *fillWorkers, *perfMode)
		return
	}

	if flag.NArg() < 1 {
		flag.Usage()
		os.Exit(2)
	}
	url := flag.Arg(0)

	// parse duration
	dur, err := time.ParseDuration(*durationStr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "invalid duration: %v\n", err)
		os.Exit(2)
	}

	// configure HTTP client for high throughput
	tr := &http.Transport{
		MaxIdleConns:        100000,
		MaxIdleConnsPerHost: *concurrency * 4,
		MaxConnsPerHost:     *concurrency * 4,
		IdleConnTimeout:     90 * time.Second,
		TLSHandshakeTimeout: 10 * time.Second,
		DisableCompression:  true,
	}
	client := &http.Client{Transport: tr, Timeout: *timeout}

	var (
		totalRequests   int64
		successRequests int64
		failedRequests  int64
		totalBytes      int64
		totalLatencyNs  int64
		maxLatencyNs    int64
	)

	ctx, cancel := context.WithTimeout(context.Background(), dur)
	defer cancel()

	// handle interrupt to stop early
	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, os.Interrupt)
	go func() {
		select {
		case <-sigCh:
			fmt.Fprintln(os.Stderr, "\ninterrupted, stopping...")
			cancel()
		case <-ctx.Done():
		}
	}()

	// start workers
	var wg sync.WaitGroup
	wg.Add(*concurrency)
	for i := 0; i < *concurrency; i++ {
		go func(workerID int) {
			defer wg.Done()
			for {
				select {
				case <-ctx.Done():
					return
				default:
				}

				start := time.Now()
				req, err := http.NewRequestWithContext(ctx, strings.ToUpper(*method), url, nil)
				if err != nil {
					atomic.AddInt64(&failedRequests, 1)
					atomic.AddInt64(&totalRequests, 1)
					continue
				}
				for _, h := range headers {
					parts := strings.SplitN(h, ":", 2)
					if len(parts) == 2 {
						req.Header.Add(strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]))
					}
				}

				resp, err := client.Do(req)
				elapsed := time.Since(start)
				atomic.AddInt64(&totalRequests, 1)
				atomic.AddInt64(&totalLatencyNs, elapsed.Nanoseconds())
				// update max latency
				for {
					old := atomic.LoadInt64(&maxLatencyNs)
					if elapsed.Nanoseconds() <= old {
						break
					}
					if atomic.CompareAndSwapInt64(&maxLatencyNs, old, elapsed.Nanoseconds()) {
						break
					}
				}

				if err != nil {
					atomic.AddInt64(&failedRequests, 1)
					continue
				}
				// count body bytes and close
				n, _ := io.Copy(io.Discard, resp.Body)
				resp.Body.Close()
				atomic.AddInt64(&totalBytes, n)
				if resp.StatusCode >= 200 && resp.StatusCode < 400 {
					atomic.AddInt64(&successRequests, 1)
				} else {
					atomic.AddInt64(&failedRequests, 1)
				}
			}
		}(i)
	}

	// reporting loop
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()

	var prevTotal int64
	var prevLatencyNs int64
	var prevBytes int64
	startTime := time.Now()
	for {
		select {
		case <-ctx.Done():
			wg.Wait()
			printSummary(&totalRequests, &successRequests, &failedRequests, &totalBytes, &totalLatencyNs, &maxLatencyNs, startTime)
			return
		case <-ticker.C:
			curTotal := atomic.LoadInt64(&totalRequests)
			curSuccess := atomic.LoadInt64(&successRequests)
			curFailed := atomic.LoadInt64(&failedRequests)
			curBytes := atomic.LoadInt64(&totalBytes)
			curLatency := atomic.LoadInt64(&totalLatencyNs)
			curMax := atomic.LoadInt64(&maxLatencyNs)

			delta := curTotal - prevTotal
			deltaBytes := curBytes - prevBytes
			deltaLatency := curLatency - prevLatencyNs
			prevTotal = curTotal
			prevBytes = curBytes
			prevLatencyNs = curLatency

			avgLatency := time.Duration(0)
			if delta > 0 {
				avgLatency = time.Duration(deltaLatency / delta)
			} else if curTotal > 0 {
				avgLatency = time.Duration(curLatency / curTotal)
			}

			fmt.Printf("[%.0fs] total=%d (+%d/s) success=%d fail=%d bytes=%.1fKB/s avg=%s max=%s\n",
				time.Since(startTime).Seconds(), curTotal, delta, curSuccess, curFailed, float64(deltaBytes)/1024.0, avgLatency, time.Duration(curMax))
		}
	}
}

func printSummary(totalPtr, successPtr, failedPtr, bytesPtr, latencyPtr, maxLatencyPtr *int64, start time.Time) {
	total := atomic.LoadInt64(totalPtr)
	success := atomic.LoadInt64(successPtr)
	failed := atomic.LoadInt64(failedPtr)
	bytes := atomic.LoadInt64(bytesPtr)
	latency := atomic.LoadInt64(latencyPtr)
	maxLatency := atomic.LoadInt64(maxLatencyPtr)
	d := time.Since(start)
	avgLatency := time.Duration(0)
	if total > 0 {
		avgLatency = time.Duration(latency / total)
	}

	fmt.Println("----- SUMMARY -----")
	fmt.Printf("duration: %s\n", d)
	fmt.Printf("requests: %d\n", total)
	fmt.Printf("success:  %d\n", success)
	fmt.Printf("failed:   %d\n", failed)
	fmt.Printf("bytes:    %.1f KB\n", float64(bytes)/1024.0)
	fmt.Printf("avg latency: %s\n", avgLatency)
	fmt.Printf("max latency: %s\n", time.Duration(maxLatency))
	fmt.Println("-------------------")
}

// parseVariableDefinitions extrai definições de variáveis no formato [var]="regex"
// de uma string. Retorna um map com as definições encontradas.
func parseVariableDefinitions(input string) map[string]string {
	definitions := make(map[string]string)
	// regex para encontrar [variavel]="valor"
	re := regexp.MustCompile(`\[([a-zA-Z0-9_\-]+)\]\s*=\s*"([^"]*)"`)
	matches := re.FindAllStringSubmatch(input, -1)

	for _, match := range matches {
		if len(match) >= 3 {
			varName := match[1]
			value := match[2]
			definitions[varName] = value
		}
	}

	return definitions
}

// RequestJob representa um trabalho de request para ser processado por workers
type RequestJob struct {
	requestNum int
	values     map[string]string
}

// RequestResult representa o resultado de uma request para ser logado
type RequestResult struct {
	timestamp      time.Time
	requestNum     int
	url            string
	method         string
	requestBody    string
	statusCode     int
	responseBody   string
	responseBytes  int
	responseTimeMs int64
	success        bool
	err            error
	variables      map[string]string
}

// runInteractiveFill lê uma request colada da entrada padrão ou de um arquivo,
// detecta tokens [[nome]] e interage com o usuário para obter uma regex ou um valor direto para substituir.
// Se filepath for fornecido, lê do arquivo. Caso contrário, lê de stdin.
// Executa com workers paralelos para máxima performance.
// Se perfMode = true, não cria logs e descarta respostas para máxima velocidade.
func runInteractiveFill(filepath string, numWorkers int, perfMode bool) {
	var input string

	if filepath != "" {
		// ler do arquivo
		data, err := os.ReadFile(filepath)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Erro ao ler arquivo %s: %v\n", filepath, err)
			os.Exit(1)
		}
		input = string(data)
		fmt.Fprintf(os.Stderr, "Lendo request de: %s\n", filepath)
	} else {
		// ler de stdin
		fmt.Fprintln(os.Stderr, "Cole a request do Chrome DevTools (formato fetch(...)) e tecle Ctrl-D:")
		input = readStdinAll()
	}

	// parsear definições de variáveis do arquivo/input
	predefinedVars := parseVariableDefinitions(input)

	// parsear a request
	req, err := parseFetchRequest(input)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Erro ao parsear request: %v\n", err)
		os.Exit(1)
	}

	// encontrar placeholders [[var]] em toda a request
	placeholderRe := regexp.MustCompile(`\[\[([a-zA-Z0-9_\-]+)\]\]`)

	// buscar em url, headers e body
	fullText := req.URL + "\n" + req.Body
	for k, v := range req.Headers {
		fullText += k + ":" + v + "\n"
	}

	matches := placeholderRe.FindAllStringSubmatch(fullText, -1)

	// map para armazenar as regexes/valores (não os valores gerados ainda)
	regexPatterns := map[string]string{}
	reader := bufio.NewReader(os.Stdin)
	rand.Seed(time.Now().UnixNano())

	// coletar regexes/valores únicos
	seen := map[string]bool{}
	for _, m := range matches {
		key := m[1]
		if seen[key] {
			continue
		}
		seen[key] = true

		// verificar se já tem definição no arquivo
		if predefinedValue, exists := predefinedVars[key]; exists {
			regexPatterns[key] = predefinedValue
			fmt.Fprintf(os.Stderr, "\n[[%s]] = \"%s\" (definido no arquivo)\n", key, predefinedValue)

			// fazer um teste de geração se for regex
			if looksLikeRegex(predefinedValue) {
				gen, err := generateFromSimpleRegex(predefinedValue)
				if err != nil {
					fmt.Fprintf(os.Stderr, "⚠ Aviso: erro ao testar regex: %v\n", err)
				} else {
					fmt.Fprintf(os.Stderr, "✓ Exemplo: %s\n", gen)
				}
			}
			continue
		}

		// se não está definido, perguntar ao usuário
		fmt.Fprintf(os.Stderr, "\nPlaceholder: [[%s]]\n", key)
		fmt.Fprintln(os.Stderr, "Digite uma regex para gerar (ex: \\d{8}, [a-z]{6}) ou valor literal:")
		fmt.Fprint(os.Stderr, "> ")
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			regexPatterns[key] = ""
			continue
		}

		// armazenar a regex ou valor literal (não gerar ainda)
		regexPatterns[key] = line

		// fazer um teste de geração se for regex
		if looksLikeRegex(line) {
			gen, err := generateFromSimpleRegex(line)
			if err != nil {
				fmt.Fprintf(os.Stderr, "⚠ Aviso: erro ao testar regex: %v\n", err)
			} else {
				fmt.Fprintf(os.Stderr, "✓ Exemplo: %s\n", gen)
			}
		}
	}

	// perguntar quantas vezes executar
	fmt.Fprint(os.Stderr, "\nQuantas vezes executar a request? ")
	line, _ := reader.ReadString('\n')
	iterations, err := strconv.Atoi(strings.TrimSpace(line))
	if err != nil || iterations <= 0 {
		fmt.Fprintln(os.Stderr, "Valor inválido, usando 1")
		iterations = 1
	}

	// perguntar delay entre requests
	fmt.Fprint(os.Stderr, "Delay entre requests em ms (0 = máximo de velocidade): ")
	line, _ = reader.ReadString('\n')
	delayMs, err := strconv.Atoi(strings.TrimSpace(line))
	if err != nil || delayMs < 0 {
		delayMs = 0
	}
	delay := time.Duration(delayMs) * time.Millisecond

	// usar todos os cores disponíveis (importante para performance)
	runtime.GOMAXPROCS(runtime.NumCPU())

	// criar logger apenas se não estiver em modo performance
	var logger *RequestLogger
	if !perfMode {
		var err error
		logger, err = NewRequestLogger()
		if err != nil {
			fmt.Fprintf(os.Stderr, "Aviso: não foi possível criar arquivo de log: %v\n", err)
			fmt.Fprintln(os.Stderr, "Continuando sem logging...")
		} else {
			defer logger.Close()
			fmt.Fprintf(os.Stderr, "📝 Log será salvo em: %s\n", logger.file.Name())
			fmt.Fprintf(os.Stderr, "💡 Dica: Para performance máxima, use -P (modo performance sem logs)\n")
		}
	} else {
		fmt.Fprintf(os.Stderr, "⚡ MODO PERFORMANCE ATIVADO - Sem logging, descartando respostas\n")
		fmt.Fprintf(os.Stderr, "⚡ Configuração: conexões ilimitadas, sem timeouts, fire-and-forget mode\n")
		fmt.Fprintf(os.Stderr, "⚡ Dica: Para performance máxima, aumente ulimit -n (file descriptors)\n")
	}

	// criar cliente HTTP otimizado para alta concorrência
	var client *http.Client
	if perfMode {
		// MODO ULTRA PERFORMANCE: sem limites, sem timeouts, conexões ilimitadas
		client = &http.Client{
			Timeout: 0, // sem timeout
			Transport: &http.Transport{
				MaxIdleConns:          0,              // ilimitado
				MaxIdleConnsPerHost:   0,              // ilimitado
				MaxConnsPerHost:       0,              // ilimitado
				IdleConnTimeout:       0,              // ilimitado
				DisableCompression:    true,           // sem compressão para speed
				DisableKeepAlives:     false,          // keep-alive ativado
				ResponseHeaderTimeout: 0,              // sem timeout
				ExpectContinueTimeout: 0,              // sem timeout
				ForceAttemptHTTP2:     true,           // tentar HTTP/2 para multiplexing
			},
		}
	} else {
		// MODO NORMAL OTIMIZADO: limites altos mas com timeouts razoáveis
		client = &http.Client{
			Timeout: 30 * time.Second,
			Transport: &http.Transport{
				MaxIdleConns:          100000,           // aumentado de 10000
				MaxIdleConnsPerHost:   numWorkers * 4,   // aumentado de *2 para *4
				MaxConnsPerHost:       numWorkers * 4,   // aumentado de *2 para *4
				IdleConnTimeout:       90 * time.Second,
				DisableCompression:    true,             // sem compressão para speed
				DisableKeepAlives:     false,            // keep-alive ativado
				ResponseHeaderTimeout: 10 * time.Second, // timeout de header
				ForceAttemptHTTP2:     true,             // tentar HTTP/2
			},
		}
	}

	// contadores atômicos para estatísticas
	var (
		successCount int64
		failCount    int64
		completed    int64
	)

	// otimizar número de workers baseado no modo
	actualWorkers := numWorkers
	if perfMode {
		if numWorkers < 500 {
			actualWorkers = 500 // mínimo de 500 workers em modo performance
			fmt.Fprintf(os.Stderr, "⚡ Modo Performance: aumentando workers para %d\n", actualWorkers)
		}
	} else {
		// modo normal: sugerir no mínimo 100 workers para boa performance
		if numWorkers < 100 {
			actualWorkers = 100
			fmt.Fprintf(os.Stderr, "🚀 Otimização: aumentando workers para %d (use -w para customizar)\n", actualWorkers)
		}
	}

	fmt.Fprintf(os.Stderr, "\n=== Executando %d requests com %d workers paralelos ===\n\n", iterations, actualWorkers)

	// canal de jobs para distribuir trabalho
	// em modo performance, usar canal menor ou sem buffer
	jobsChanSize := iterations
	if perfMode {
		jobsChanSize = actualWorkers * 2 // canal menor em modo performance
	}
	jobs := make(chan RequestJob, jobsChanSize)

	// canal de resultados para logging (apenas em modo normal)
	var resultsChan chan RequestResult
	if !perfMode {
		resultsChan = make(chan RequestResult, actualWorkers*10) // buffer grande para não bloquear
	}

	// iniciar workers de logging (separados das requests)
	numLogWorkers := 10 // workers dedicados apenas para logging
	var logWg sync.WaitGroup
	if !perfMode && logger != nil {
		for i := 0; i < numLogWorkers; i++ {
			logWg.Add(1)
			go func() {
				defer logWg.Done()
				for result := range resultsChan {
					// criar entrada de log
					logEntry := RequestLogEntry{
						Timestamp:      result.timestamp.Format(time.RFC3339Nano),
						RequestNum:     result.requestNum,
						URL:            result.url,
						Method:         result.method,
						ResponseTimeMs: result.responseTimeMs,
						Variables:      result.variables,
						StatusCode:     result.statusCode,
						ResponseBytes:  result.responseBytes,
						Success:        result.success,
					}

					// incluir bodies
					if result.requestBody != "" {
						logEntry.RequestBody = result.requestBody
					}
					if result.responseBody != "" {
						logEntry.ResponseBody = result.responseBody
					}
					if result.err != nil {
						logEntry.Error = result.err.Error()
					}

					// salvar no log
					logger.LogAsync(logEntry)
				}
			}()
		}
	}

	// canal de resultados (opcional, apenas para tracking)
	var wg sync.WaitGroup

	// iniciar workers
	for w := 0; w < actualWorkers; w++ {
		wg.Add(1)
		go func(workerID int) {
			defer wg.Done()

			for job := range jobs {
				currentValues := job.values

				// criar cópias da request com novos valores
				currentURL := placeholderRe.ReplaceAllStringFunc(req.URL, func(s string) string {
					sub := placeholderRe.FindStringSubmatch(s)
					if len(sub) >= 2 {
						if v, ok := currentValues[sub[1]]; ok {
							return v
						}
					}
					return s
				})

				currentBody := placeholderRe.ReplaceAllStringFunc(req.Body, func(s string) string {
					sub := placeholderRe.FindStringSubmatch(s)
					if len(sub) >= 2 {
						if v, ok := currentValues[sub[1]]; ok {
							return v
						}
					}
					return s
				})

				currentHeaders := make(map[string]string)
				for k, v := range req.Headers {
					currentHeaders[k] = placeholderRe.ReplaceAllStringFunc(v, func(s string) string {
						sub := placeholderRe.FindStringSubmatch(s)
						if len(sub) >= 2 {
							if val, ok := currentValues[sub[1]]; ok {
								return val
							}
						}
						return s
					})
				}

				// criar e executar request HTTP
				var bodyReader io.Reader
				if currentBody != "" {
					bodyReader = strings.NewReader(currentBody)
				}

				httpReq, err := http.NewRequest(req.Method, currentURL, bodyReader)
				if err != nil {
					atomic.AddInt64(&failCount, 1)
					atomic.AddInt64(&completed, 1)
					continue
				}

				for k, v := range currentHeaders {
					httpReq.Header.Set(k, v)
				}

				if perfMode {
					// MODO ULTRA PERFORMANCE: fire and forget, sem esperar resposta
					go func() {
						resp, err := client.Do(httpReq)
						if err == nil {
							resp.Body.Close() // fechar imediatamente sem ler
							atomic.AddInt64(&successCount, 1)
						} else {
							atomic.AddInt64(&failCount, 1)
						}
						atomic.AddInt64(&completed, 1)
					}()
				} else {
					// MODO NORMAL OTIMIZADO: request rápida + envia resultado para workers de log
					go func(reqCopy *http.Request, jobNum int, vals map[string]string, url, body string) {
						start := time.Now()
						resp, err := client.Do(reqCopy)
						elapsed := time.Since(start)

						if err != nil {
							atomic.AddInt64(&failCount, 1)
							atomic.AddInt64(&completed, 1)

							// enviar resultado com erro para logging
							if resultsChan != nil {
								select {
								case resultsChan <- RequestResult{
									timestamp:      start,
									requestNum:     jobNum,
									url:            url,
									method:         req.Method,
									requestBody:    body,
									responseTimeMs: elapsed.Milliseconds(),
									success:        false,
									err:            err,
									variables:      vals,
								}:
								default:
									// canal cheio, descarta
								}
							}
							return
						}

						// ler resposta rapidamente
						respBody, _ := io.ReadAll(resp.Body)
						resp.Body.Close()

						success := resp.StatusCode < 400
						if success {
							atomic.AddInt64(&successCount, 1)
						} else {
							atomic.AddInt64(&failCount, 1)
						}
						atomic.AddInt64(&completed, 1)

						// enviar resultado para workers de logging (não-bloqueante)
						if resultsChan != nil {
							select {
							case resultsChan <- RequestResult{
								timestamp:      start,
								requestNum:     jobNum,
								url:            url,
								method:         req.Method,
								requestBody:    body,
								statusCode:     resp.StatusCode,
								responseBody:   string(respBody),
								responseBytes:  len(respBody),
								responseTimeMs: elapsed.Milliseconds(),
								success:        success,
								variables:      vals,
							}:
							default:
								// canal cheio, descarta log mas continua
							}
						}
					}(httpReq, job.requestNum, currentValues, currentURL, currentBody)

					// delay entre requests (se configurado)
					// nota: delay aplica ao disparo, não à conclusão
					if delay > 0 {
						time.Sleep(delay)
					}
				}
			}
		}(w)
	}

	// gerar jobs e enviar para os workers
	startTime := time.Now()
	for i := 0; i < iterations; i++ {
		// gerar novos valores para cada request
		currentValues := make(map[string]string)
		for key, pattern := range regexPatterns {
			if looksLikeRegex(pattern) {
				gen, err := generateFromSimpleRegex(pattern)
				if err != nil {
					currentValues[key] = pattern
				} else {
					currentValues[key] = gen
				}
			} else {
				currentValues[key] = pattern
			}
		}

		jobs <- RequestJob{
			requestNum: i + 1,
			values:     currentValues,
		}
	}
	close(jobs)

	// reporter thread para mostrar progresso em tempo real
	done := make(chan struct{})
	go func() {
		// em modo performance, atualizar menos frequentemente para economizar CPU
		reportInterval := 500 * time.Millisecond
		if perfMode {
			reportInterval = 2 * time.Second // menos frequente em modo performance
		}
		ticker := time.NewTicker(reportInterval)
		defer ticker.Stop()

		for {
			select {
			case <-ticker.C:
				c := atomic.LoadInt64(&completed)
				s := atomic.LoadInt64(&successCount)
				f := atomic.LoadInt64(&failCount)
				pct := float64(c) / float64(iterations) * 100
				fmt.Fprintf(os.Stderr, "\r[%.1f%%] Completo: %d | Sucesso: %d | Falha: %d", pct, c, s, f)
			case <-done:
				return
			}
		}
	}()

	// aguardar workers terminarem de disparar
	wg.Wait()

	// aguardar todas as requests completarem (com timeout de segurança)
	fmt.Fprintf(os.Stderr, "\n⏳ Aguardando conclusão de todas as requests...\n")
	waitStart := time.Now()
	maxWaitTime := 5 * time.Minute // timeout de 5 minutos

	for {
		c := atomic.LoadInt64(&completed)
		if c >= int64(iterations) {
			break
		}

		// verificar timeout
		if time.Since(waitStart) > maxWaitTime {
			fmt.Fprintf(os.Stderr, "\n⚠️  Timeout: nem todas as requests completaram em %s\n", maxWaitTime)
			break
		}

		time.Sleep(100 * time.Millisecond)

		// mostrar progresso enquanto aguarda
		s := atomic.LoadInt64(&successCount)
		f := atomic.LoadInt64(&failCount)
		pct := float64(c) / float64(iterations) * 100
		fmt.Fprintf(os.Stderr, "\r[%.1f%%] Completo: %d | Sucesso: %d | Falha: %d", pct, c, s, f)
	}

	close(done)

	// fechar canal de resultados e aguardar workers de logging terminarem
	if !perfMode && resultsChan != nil {
		fmt.Fprintf(os.Stderr, "\n💾 Finalizando processamento de logs...\n")
		close(resultsChan) // fecha canal, sinalizando para workers pararem
		logWg.Wait()       // aguarda workers de logging terminarem

		// aguardar até que o canal de logs do logger esteja vazio
		if logger != nil {
			maxLogWait := 30 * time.Second
			logWaitStart := time.Now()

			for {
				pending := logger.PendingLogs()
				if pending == 0 {
					break
				}

				if time.Since(logWaitStart) > maxLogWait {
					fmt.Fprintf(os.Stderr, "⚠️  Aviso: ainda há ~%d logs pendentes após %s\n", pending, maxLogWait)
					break
				}

				fmt.Fprintf(os.Stderr, "\r💾 Aguardando escrita de ~%d logs...", pending)
				time.Sleep(200 * time.Millisecond)
			}

			// aguardar flush final
			time.Sleep(500 * time.Millisecond)
			fmt.Fprintf(os.Stderr, "\r✅ Todos os logs foram escritos!                    \n")
		}
	}

	elapsed := time.Since(startTime)
	finalCompleted := atomic.LoadInt64(&completed)
	finalSuccess := atomic.LoadInt64(&successCount)
	finalFailed := atomic.LoadInt64(&failCount)
	reqPerSec := float64(finalCompleted) / elapsed.Seconds()

	fmt.Fprintf(os.Stderr, "\n\n=== Resumo ===\n")
	fmt.Fprintf(os.Stderr, "Total Disparado: %d | Completado: %d\n", iterations, finalCompleted)
	fmt.Fprintf(os.Stderr, "Sucesso: %d | Falha: %d\n", finalSuccess, finalFailed)
	fmt.Fprintf(os.Stderr, "Tempo total: %s\n", elapsed)
	fmt.Fprintf(os.Stderr, "Requests/segundo: %.2f\n", reqPerSec)

	if logger != nil {
		fmt.Fprintf(os.Stderr, "📄 Log salvo em: %s\n", logger.file.Name())
	}
}

type FetchRequest struct {
	URL     string
	Method  string
	Headers map[string]string
	Body    string
}

// parseFetchRequest extrai informações da request fetch() colada
func parseFetchRequest(input string) (*FetchRequest, error) {
	req := &FetchRequest{
		Method:  "GET",
		Headers: make(map[string]string),
	}

	// extrair URL - primeira string após fetch(
	urlRe := regexp.MustCompile(`fetch\s*\(\s*["']([^"']+)["']`)
	urlMatch := urlRe.FindStringSubmatch(input)
	if len(urlMatch) < 2 {
		return nil, fmt.Errorf("URL não encontrada no fetch()")
	}
	req.URL = urlMatch[1]

	// extrair method
	methodRe := regexp.MustCompile(`["']method["']\s*:\s*["']([^"']+)["']`)
	if methodMatch := methodRe.FindStringSubmatch(input); len(methodMatch) >= 2 {
		req.Method = strings.ToUpper(methodMatch[1])
	}

	// extrair headers
	headersRe := regexp.MustCompile(`["']headers["']\s*:\s*\{([^}]+)\}`)
	if headersMatch := headersRe.FindStringSubmatch(input); len(headersMatch) >= 2 {
		headerBlock := headersMatch[1]
		headerLineRe := regexp.MustCompile(`["']([^"']+)["']\s*:\s*["']([^"']*)["']`)
		for _, match := range headerLineRe.FindAllStringSubmatch(headerBlock, -1) {
			if len(match) >= 3 {
				req.Headers[match[1]] = match[2]
			}
		}
	}

	// extrair body - melhor handling de strings com escape
	bodyRe := regexp.MustCompile(`["']body["']\s*:\s*["']((?:[^"'\\]|\\.)*)["']`)
	if bodyMatch := bodyRe.FindStringSubmatch(input); len(bodyMatch) >= 2 {
		body := bodyMatch[1]
		// decodificar escapes: \" para " e \\ para \
		body = strings.ReplaceAll(body, `\"`, `"`)
		body = strings.ReplaceAll(body, `\\`, `\`)
		req.Body = body
	}

	return req, nil
}

func readStdinAll() string {
	var b strings.Builder
	sc := bufio.NewScanner(os.Stdin)
	for sc.Scan() {
		b.WriteString(sc.Text())
		b.WriteString("\n")
	}
	return b.String()
}

// looksLikeRegex tenta heurísticamente detectar se a entrada aparenta ser uma regex
func looksLikeRegex(s string) bool {
	if strings.Contains(s, "\\d") || strings.Contains(s, "\\w") {
		return true
	}
	if strings.ContainsAny(s, "[]{}+*?") {
		return true
	}
	// barras indicando classes
	if strings.HasPrefix(s, "^") || strings.HasSuffix(s, "$") {
		return true
	}
	return false
}

// generateFromSimpleRegex implementa um gerador bem simples que suporta:
// \d, \w, [abc], [a-z], quantifiers {n} {n,m}, +, *, ?
func generateFromSimpleRegex(pattern string) (string, error) {
	// remover ^ $ se presentes
	pattern = strings.TrimPrefix(pattern, "^")
	pattern = strings.TrimSuffix(pattern, "$")

	// usar builder do pool para performance
	out := getBuilder()
	defer putBuilder(out)

	i := 0
	for i < len(pattern) {
		c := pattern[i]
		if c == '\\' && i+1 < len(pattern) {
			next := pattern[i+1]
			switch next {
			case 'd':
				// default 1 digit, verificar quantifier após
				rep, adv := parseQuantifier(pattern, i+2)
				out.WriteString(randDigits(rep))
				i = adv
				continue
			case 'w':
				rep, adv := parseQuantifier(pattern, i+2)
				out.WriteString(randWord(rep))
				i = adv
				continue
			default:
				out.WriteByte(next)
				i += 2
				continue
			}
		}

		if c == '[' {
			// find closing ]
			j := strings.IndexByte(pattern[i:], ']')
			if j == -1 {
				return "", fmt.Errorf("unterminated character class")
			}
			class := pattern[i+1 : i+j]
			rep, adv := parseQuantifier(pattern, i+j+1)
			out.WriteString(randFromClass(class, rep))
			i = adv
			continue
		}

		// quantifiers after literal
		if c == '{' {
			// skip unknown
			i++
			continue
		}

		// literal char
		out.WriteByte(c)
		i++
	}

	return out.String(), nil
}

// parseQuantifier lê quantifier começando em idx e retorna (repeat, newIdx)
func parseQuantifier(s string, idx int) (int, int) {
	if idx >= len(s) {
		return 1, idx
	}
	switch s[idx] {
	case '+':
		return randRange(1, 6), idx + 1
	case '*':
		return randRange(0, 6), idx + 1
	case '?':
		if rand.Intn(2) == 0 {
			return 0, idx + 1
		}
		return 1, idx + 1
	case '{':
		// find closing }
		j := strings.IndexByte(s[idx:], '}')
		if j == -1 {
			return 1, idx
		}
		body := s[idx+1 : idx+j]
		parts := strings.Split(body, ",")
		if len(parts) == 1 {
			n, _ := strconv.Atoi(strings.TrimSpace(parts[0]))
			return n, idx + j + 1
		}
		lo, _ := strconv.Atoi(strings.TrimSpace(parts[0]))
		hi := lo
		if len(parts) > 1 {
			hi, _ = strconv.Atoi(strings.TrimSpace(parts[1]))
		}
		if hi < lo {
			hi = lo
		}
		return randRange(lo, hi), idx + j + 1
	default:
		return 1, idx
	}
}

func randRange(lo, hi int) int {
	if hi <= lo {
		return lo
	}
	return rand.Intn(hi-lo+1) + lo
}

// Pool de byte slices para geração de strings
var byteSlicePool = sync.Pool{
	New: func() any {
		b := make([]byte, 64) // tamanho inicial padrão
		return &b
	},
}

func randDigits(n int) string {
	if n <= 0 {
		return ""
	}

	bp := byteSlicePool.Get().(*[]byte)
	defer byteSlicePool.Put(bp)

	b := *bp
	if len(b) < n {
		b = make([]byte, n)
	} else {
		b = b[:n]
	}

	for i := 0; i < n; i++ {
		b[i] = byte('0' + rand.Intn(10))
	}
	return string(b)
}

const wordChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"

func randWord(n int) string {
	if n <= 0 {
		return ""
	}

	bp := byteSlicePool.Get().(*[]byte)
	defer byteSlicePool.Put(bp)

	b := *bp
	if len(b) < n {
		b = make([]byte, n)
	} else {
		b = b[:n]
	}

	for i := 0; i < n; i++ {
		b[i] = wordChars[rand.Intn(len(wordChars))]
	}
	return string(b)
}

// Cache de character classes expandidas para evitar reprocessamento
var charClassCache = sync.Map{}

func expandCharClass(class string) []rune {
	// tentar obter do cache
	if cached, ok := charClassCache.Load(class); ok {
		return cached.([]rune)
	}

	chars := make([]rune, 0, len(class))
	i := 0
	for i < len(class) {
		if i+2 < len(class) && class[i+1] == '-' {
			for c := class[i]; c <= class[i+2]; c++ {
				chars = append(chars, rune(c))
			}
			i += 3
			continue
		}
		chars = append(chars, rune(class[i]))
		i++
	}
	if len(chars) == 0 {
		chars = append(chars, 'x')
	}

	// salvar no cache
	charClassCache.Store(class, chars)
	return chars
}

func randFromClass(class string, n int) string {
	if n <= 0 {
		return ""
	}

	chars := expandCharClass(class)

	bp := byteSlicePool.Get().(*[]byte)
	defer byteSlicePool.Put(bp)

	// alocar slice de runes temporário
	runes := make([]rune, n)
	for i := 0; i < n; i++ {
		runes[i] = chars[rand.Intn(len(chars))]
	}

	return string(runes)
}