main.go

package main

import (
	"fmt"
	"net"
	"os"
	"os/signal"
	"strconv"
	"syscall"
	"time"

	"github.com/fatih/color"
)

// Statistics holds connection statistics
type Statistics struct {
	Total        int
	Successful   int
	Failed       int
	TotalLatency float64
}

func printBanner() {
	cyan := color.New(color.FgCyan).SprintFunc()
	yellow := color.New(color.FgYellow).SprintFunc()

	fmt.Printf("\n%s\n", cyan("╔═══════════════════════════════════════╗"))
	fmt.Printf("%s  %s      %s\n", cyan("║"), yellow("⚡ TCPing - TCP Port Tester ⚡"), cyan("║"))
	fmt.Printf("%s\n\n", cyan("╚═══════════════════════════════════════╝"))
}

func validateArgs() (string, int) {
	if len(os.Args) != 3 {
		color.Red("✗ Error: Invalid arguments")
		color.Yellow("Usage: %s <ip> <port>", os.Args[0])
		color.Cyan("Example: %s 8.8.8.8 53", os.Args[0])
		os.Exit(1)
	}

	host := os.Args[1]
	port, err := strconv.Atoi(os.Args[2])
	if err != nil || port < 1 || port > 65535 {
		color.Red("✗ Error: Port must be a number between 1 and 65535")
		os.Exit(1)
	}

	return host, port
}

func tcping(host string, port int, timeout time.Duration) (bool, float64, string) {
	address := fmt.Sprintf("%s:%d", host, port)
	start := time.Now()

	conn, err := net.DialTimeout("tcp", address, timeout)
	elapsed := time.Since(start).Seconds() * 1000 // Convert to milliseconds

	if err != nil {
		if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
			return false, elapsed, "Timeout"
		}
		return false, elapsed, "Connection refused"
	}

	conn.Close()
	return true, elapsed, ""
}

func getLatencyColor(latency float64) *color.Color {
	if latency < 50 {
		return color.New(color.FgGreen)
	} else if latency < 150 {
		return color.New(color.FgYellow)
	}
	return color.New(color.FgRed)
}

func printStatistics(stats Statistics, host string, port int) {
	cyan := color.New(color.FgCyan).SprintFunc()
	white := color.New(color.FgWhite).SprintFunc()
	green := color.New(color.FgGreen).SprintFunc()
	red := color.New(color.FgRed).SprintFunc()
	yellow := color.New(color.FgYellow).SprintFunc()

	fmt.Printf("\n\n%s\n", cyan("────────────────────────────────────────────────────────────"))
	fmt.Printf("%s\n", yellow(fmt.Sprintf("📊 Statistics for %s:%d", host, port)))
	fmt.Printf("%s\n", cyan("────────────────────────────────────────────────────────────"))

	if stats.Total > 0 {
		successRate := float64(stats.Successful) / float64(stats.Total) * 100

		fmt.Printf("%s %s\n", white("Total probes:"), cyan(fmt.Sprintf("%d", stats.Total)))
		fmt.Printf("%s %s\n", white("Successful:"), green(fmt.Sprintf("%d", stats.Successful)))
		fmt.Printf("%s %s\n", white("Failed:"), red(fmt.Sprintf("%d", stats.Failed)))
		fmt.Printf("%s %s\n", white("Success rate:"), yellow(fmt.Sprintf("%.1f%%", successRate)))

		if stats.Successful > 0 {
			avgLatency := stats.TotalLatency / float64(stats.Successful)
			latencyColor := getLatencyColor(avgLatency)
			fmt.Printf("%s %s\n", white("Average latency:"), latencyColor.Sprintf("%.2fms", avgLatency))
		}
	}

	fmt.Printf("%s\n", cyan("────────────────────────────────────────────────────────────"))
	color.Green("✓ TCPing terminated\n")
}

func main() {
	printBanner()
	host, port := validateArgs()

	color.Cyan("Target: %s", color.WhiteString("%s:%d", host, port))
	color.Cyan("Timeout: %s", color.WhiteString("3 seconds"))
	color.Cyan("────────────────────────────────────────────────────────────\n")

	stats := Statistics{}
	seq := 0

	// Setup signal handling for Ctrl+C
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)

	// Ticker for periodic pings
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()

	// Channel to signal done
	done := make(chan bool)

	go func() {
		for {
			select {
			case <-ticker.C:
				seq++
				timestamp := time.Now().Format("15:04:05")

				success, latency, errorMsg := tcping(host, port, 3*time.Second)
				stats.Total++

				white := color.New(color.FgWhite).SprintFunc()
				cyan := color.New(color.FgCyan).SprintFunc()

				if success {
					stats.Successful++
					stats.TotalLatency += latency
					latencyColor := getLatencyColor(latency)

					fmt.Printf("%s %s Connected to %s - seq=%d time=%s\n",
						white(fmt.Sprintf("[%s]", timestamp)),
						color.GreenString("✓"),
						cyan(fmt.Sprintf("%s:%d", host, port)),
						seq,
						latencyColor.Sprintf("%.2fms", latency))
				} else {
					stats.Failed++
					fmt.Printf("%s %s Cannot reach destination %s - %s\n",
						white(fmt.Sprintf("[%s]", timestamp)),
						color.RedString("✗"),
						color.RedString("%s:%d", host, port),
						color.RedString(errorMsg))
				}
			case <-done:
				return
			}
		}
	}()

	// Wait for interrupt signal
	<-sigChan
	done <- true
	time.Sleep(100 * time.Millisecond) // Give time for last message to print

	printStatistics(stats, host, port)
}