package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"proxmox-router/internal/api"
	"proxmox-router/internal/auth"
	"proxmox-router/internal/bridge"
	"proxmox-router/internal/bwtest"
	"proxmox-router/internal/cli"
	"proxmox-router/internal/dhcp"
	"proxmox-router/internal/dns"
	"proxmox-router/internal/dynamicrouting"
	"proxmox-router/internal/firewall"
	"proxmox-router/internal/logging"
	"proxmox-router/internal/network"
	"proxmox-router/internal/routing"
	"proxmox-router/internal/services"
	"proxmox-router/internal/tools"
	"proxmox-router/internal/vpn"
	"proxmox-router/internal/vrrp"
	"proxmox-router/internal/web"
)

func main() {
	addr := flag.String("addr", ":8080", "HTTP service address (e.g. :8080 or :80)")
	cliAddr := flag.String("cli-addr", ":8282", "CLI service address for Telnet and debtik-cli (e.g. :8282)")
	metaPath := flag.String("meta", "/etc/proxmox-router/metadata.json", "Path to interface metadata storage file")
	flag.Parse()

	// Initialize Logging Ring Buffer
	_ = logging.GetLogger()

	// Initialize components
	metaMgr := network.NewMetadataManager(*metaPath)
	netMgr := network.NewManager(metaMgr)
	persistMgr := network.NewPersistenceManager(netMgr)
	vpnMgr := vpn.NewManager()
	fwMgr := firewall.NewFirewallManager()
	routingMgr := routing.NewRoutingManager()
	defer routingMgr.Stop()
	dynRoutingMgr := dynamicrouting.NewManager("")
	bridgeMgr := bridge.NewBridgeManager()
	toolsMgr := tools.NewManager()
	dhcpMgr := dhcp.NewManager()
	dhcpServerMgr := dhcp.NewServerManager()
	vrrpMgr := vrrp.NewManager()
	bwtestMgr := bwtest.NewManager("")
	defer bwtestMgr.Stop()
	dnsMgr := dns.NewManager()
	authMgr := auth.NewManager("")
	servicesMgr := services.NewManager("")
	webHandler := web.Handler()

	// Build Unified RouterOS CLI Executor
	cliExecutor := cli.NewExecutor(
		authMgr,
		netMgr,
		routingMgr,
		dynRoutingMgr,
		fwMgr,
		dhcpMgr,
		dhcpServerMgr,
		dnsMgr,
		bridgeMgr,
		vpnMgr,
		vrrpMgr,
		bwtestMgr,
		servicesMgr,
	)

	// Determine Telnet & SSH addresses from services config or flags
	telnetAddr := *cliAddr
	if tSvc, ok := servicesMgr.GetService("telnet"); ok && tSvc.Port > 0 {
		telnetAddr = fmt.Sprintf(":%d", tSvc.Port)
	}

	sshAddr := ":2222"
	if sSvc, ok := servicesMgr.GetService("ssh"); ok && sSvc.Port > 0 {
		sshAddr = fmt.Sprintf(":%d", sSvc.Port)
	}

	cliTelnetServer := cli.NewServer(telnetAddr, authMgr, cliExecutor)
	cliSSHServer := cli.NewSSHServer(sshAddr, authMgr, cliExecutor)

	// Register hooks for dynamic service start/stop
	servicesMgr.RegisterHook("telnet", func(serviceName string, port int, disabled bool) error {
		if disabled {
			cliTelnetServer.Stop()
		} else {
			cliTelnetServer.SetAddr(fmt.Sprintf(":%d", port))
			go func() {
				if err := cliTelnetServer.Start(); err != nil {
					log.Printf("[CLI-Telnet] Listener error: %v", err)
				}
			}()
		}
		return nil
	})

	servicesMgr.RegisterHook("ssh", func(serviceName string, port int, disabled bool) error {
		if disabled {
			cliSSHServer.Stop()
		} else {
			cliSSHServer.SetAddr(fmt.Sprintf(":%d", port))
			go func() {
				if err := cliSSHServer.Start(); err != nil {
					log.Printf("[CLI-SSH] Listener error: %v", err)
				}
			}()
		}
		return nil
	})

	// Start enabled CLI servers
	if tSvc, ok := servicesMgr.GetService("telnet"); !ok || !tSvc.Disabled {
		go func() {
			if err := cliTelnetServer.Start(); err != nil {
				log.Printf("[CLI-Telnet] Server listener error: %v", err)
			}
		}()
	}
	defer cliTelnetServer.Stop()

	if sSvc, ok := servicesMgr.GetService("ssh"); !ok || !sSvc.Disabled {
		go func() {
			if err := cliSSHServer.Start(); err != nil {
				log.Printf("[CLI-SSH] Server listener error: %v", err)
			}
		}()
	}
	defer cliSSHServer.Stop()

	// API & Web UI Server
	srv := api.NewServer(
		netMgr,
		persistMgr,
		metaMgr,
		vpnMgr,
		fwMgr,
		routingMgr,
		dynRoutingMgr,
		bridgeMgr,
		toolsMgr,
		dhcpMgr,
		dhcpServerMgr,
		vrrpMgr,
		bwtestMgr,
		dnsMgr,
		authMgr,
		servicesMgr,
		webHandler,
	)

	httpServer := &http.Server{
		Addr:         *addr,
		Handler:      srv,
		ReadTimeout:  60 * time.Second,
		WriteTimeout: 60 * time.Second,
		IdleTimeout:  120 * time.Second,
	}

	// Print startup banner
	fmt.Println("========================================================")
	fmt.Println("      ⚡ Proxmox RouterOS Appliance Controller ⚡        ")
	fmt.Println("========================================================")
	fmt.Printf(" Web UI & API        : http://0.0.0.0%s\n", *addr)
	fmt.Printf(" CLI Telnet Service  : 0.0.0.0%s (debtik-cli / telnet)\n", telnetAddr)
	fmt.Printf(" CLI SSH Service     : 0.0.0.0%s (ssh admin@<router-ip> -p 2222)\n", sshAddr)
	fmt.Printf(" Metadata Storage    : %s\n", *metaPath)
	fmt.Printf(" Debian Config Path  : %s\n", network.DebianVlansCfgPath)

	if ifaces, err := netMgr.ListInterfaces(); err == nil {
		fmt.Printf(" Discovered Links    : %d interfaces\n", len(ifaces))
		for _, i := range ifaces {
			fmt.Printf("   - %-10s (%s) [%s] MTU:%d\n", i.Name, i.Type, i.State, i.MTU)
		}
	}
	fmt.Println("========================================================")
	fmt.Println(" DebTik Appliance ready. Press Ctrl+C to terminate.")

	// Graceful shutdown handling
	stopChan := make(chan os.Signal, 1)
	signal.Notify(stopChan, os.Interrupt, syscall.SIGTERM)

	go func() {
		if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("HTTP server failed: %v", err)
		}
	}()

	<-stopChan
	fmt.Println("\nShutting down RouterOS Controller gracefully...")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	if err := httpServer.Shutdown(ctx); err != nil {
		log.Printf("Server shutdown error: %v", err)
	}
	fmt.Println("RouterOS Controller stopped.")
}