// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
// Use of this source code is governed by the GPL 3.0

package main

import (
	"embed"
	"fmt"
	"io"
	"net"
	"os"
	"time"

	"github.com/google/uuid"
	"go.wit.com/dev/alexflint/arg"
	"go.wit.com/gui"
	"go.wit.com/log"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

var VERSION string
var BUILDTIME string

//go:embed resources/*
var resources embed.FS

func main() {
	var pp *arg.Parser
	gui.InitArg()
	pp = arg.MustParse(&argv)

	if pp == nil {
		pp.WriteHelp(os.Stdout)
		os.Exit(0)
	}
	log.Info("tmp hack", uuid.New().String())

	me = new(gusconf)
	me.pollDelay = 10 * time.Second
	me.portmaps = ConfigLoad()
	me.events = EventLoad()

	if me.portmaps == nil {
		me.portmaps = NewPortmaps()
		p := new(Portmap)
		p.Connect = "testing:323"
		me.portmaps.Append(p)
	}

	if argv.Daemon {
		// turn off timestamps for STDOUT (systemd adds them)
		log.DaemonMode(true)
		startHTTP()
		os.Exit(0)
	}

	if gui.NoGui() {
		all := me.portmaps.All()
		for all.Scan() {
			pm := all.Next()
			if !pm.Enabled {
				continue
			}
			log.Info("portmap enabled for port", pm.Listen, "to", pm.Connect)
			go gus3000(int(pm.Listen), pm.Connect)
		}
		startHTTP()
		os.Exit(0)
	}

	all := me.portmaps.All()
	for all.Scan() {
		pm := all.Next()
		if !pm.Enabled {
			continue
		}
		log.Info("portmap enabled for port", pm.Listen, "to", pm.Connect)
		go gus3000(int(pm.Listen), pm.Connect)
	}
	// go NewWatchdog()
	go startHTTP()
	doGui()
}

func gus3000(port int, connect string) {
	// Listen on local port 3000
	s := fmt.Sprintf("0.0.0.0:%d", port)
	listener, err := net.Listen("tcp", s)
	if err != nil {
		log.Fatalf("Failed to listen on %s: %v", s, err)
	}
	defer listener.Close()
	log.Info("Listening on ", s)

	for {
		// Accept incoming connection
		clientConn, err := listener.Accept()
		if err != nil {
			log.Printf("Failed to accept client connection: %v", err)
			continue
		}
		// log.Printf("Client connected: %s", clientConn.RemoteAddr())

		// Handle the connection in a separate goroutine
		go handleConnection(clientConn, connect, port)
	}
}

func handleConnection(clientConn net.Conn, where string, localport int) {
	defer clientConn.Close()

	// Connect to the target server
	// targetConn, err := net.Dial("tcp", "go.wit.com:80")
	targetConn, err := net.Dial("tcp", where)
	if err != nil {
		log.Printf("Failed to connect to %s %v", where, err)
		return
	}
	defer targetConn.Close()
	// log.Printf("Connected to target server: %s where = %s\n", targetConn.RemoteAddr(), where)
	log.Printf("Connected on port %d from client: %s to where = %s\n", localport, clientConn.RemoteAddr(), where)

	e := new(Event)
	e.Address = fmt.Sprintf("%s\n", clientConn.RemoteAddr())
	e.Where = where
	e.Ctime = timestamppb.New(time.Now())

	me.events.Append(e)

	// Bidirectional copy of data
	go io.Copy(targetConn, clientConn) // Client -> Target
	io.Copy(clientConn, targetConn)    // Target -> Client
	e.Etime = timestamppb.New(time.Now())
}