package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"github.com/Akilan1999/p2p-rendering-computation/abstractions"
	"github.com/Akilan1999/remotegameplay/config"
	"github.com/Akilan1999/remotegameplay/core"
	gameserver "github.com/Akilan1999/remotegameplay/server"
	"log"
	"math/rand"
	"net/http"
	"os/exec"
	"time"
)

func main() {
	addr := flag.String("addr", "0.0.0.0", "Listen address")
	//port := flag.String("port", "8888", "port for  running the server")
	barrier := flag.Bool("barrier", false, "set external port barrier")
	tls := flag.Bool("tls", false, "Use TLS")
	setconfig := flag.Bool("setconfig", false, "Generates a config file")
	certFile := flag.String("certFile", "files/server.crt", "TLS cert file")
	keyFile := flag.String("keyFile", "files/server.key", "TLS key file")
	headless := flag.Bool("headless", false, "Creating screenshare using headless mode")
	roomInfo := flag.Bool("roomInfo", false, "Getting room id of headless server")
	killServer := flag.Bool("killServer", false, "Kills the laplace")
	killChromium := flag.Bool("killChromium", false, "Kills all chromuim")
	BinaryToExecute := flag.String("BinaryToExecute", "", "Providing path (i.e Absolute path) of binary to execute")
	GameServer := flag.Bool("GameServer", false, "Starts the game server by default")
	Migrate := flag.Bool("Migrate", false, "Sets up the tables for the Sqlite database")
	BothServers := flag.Bool("BothServers", false, "Starts the Gameserver and screenshare. Also ensures the screenshare can broadcast the availability to the game server")

	flag.Parse()

	// Start P2PRC
	abstractions.Start()

	rand.Seed(time.Now().UnixNano())
	server := core.GetHttp()

	if *setconfig {
		err := config.SetDefaults()
		if err != nil {
			return
		}
		return
	}

	Config, err := config.ConfigInit()
	if err != nil {
		log.Fatalln(err)
	}

	// if barrier flag is provided
	if *barrier {
		natBarrier, err := core.EscapeNATBarrier()
		if err != nil {
			fmt.Println(err)
			return
		}
		Config.NATEscapeBarrierPort = natBarrier
		Config.NATEscapeBarrierPort = "0"
		err = Config.WriteConfig()
		if err != nil {
			return
		}
		fmt.Println(Config.IPAddress + ":" + Config.NATEscapeBarrierPort)

		// Starts infinite loop to FRP server running for escaping NAT
		for {

		}
	}

	// Print out room information
	if *roomInfo {
		room, err := core.ReadRoomsFile()
		if err != nil {
			log.Fatalln(err)
		}

		PrettyPrint(room)
		return
	}

	// kills laplace server
	if *killServer {
		cmd := exec.Command("pkill", "remotegameplay")
		if err := cmd.Run(); err != nil {
			fmt.Println(err)
		}
		return
	}
	// kills chromium server
	if *killChromium {
		cmd := exec.Command("pkill", "chromium")
		if err := cmd.Run(); err != nil {
			fmt.Println(err)
		}
		return
	}

	if *Migrate {
		// Connect to Sqlite
		connect, err := gameserver.Connect()
		if err != nil {
			fmt.Println(err)
		}
		// Migrate table
		session, err := gameserver.CreateTables(connect)
		if err != nil {
			fmt.Println(err)
		}
		session.Scan(gameserver.GameSession{})

		return
	}

	// running implementation to escape NAT
	GameServerPort, ScreenSharePort, err := core.EscapeNAT(Config.InternalScreenSharePort, Config.InternalGameServerPort)
	if err != nil {
		log.Fatalln(err)
	}

	Config.IPAddress = ""
	Config.NATEscapeGameServerPort = GameServerPort
	Config.NATEscapeScreenSharePort = ScreenSharePort
	Config.NATEscapeBarrierPort = ""

	err = Config.WriteConfig()
	if err != nil {
		log.Fatalln(err)
	}

	// If both server and screenshare have be triggered (first set the according flags to true)
	if *BothServers {
		*headless = true
		*tls = true
		*GameServer = true
	}

	if *GameServer {
		go gameserver.Server(Config.InternalGameServerPort)
		time.Sleep(2 * time.Second)
	}

	if !*GameServer || *BothServers {
		if *tls {
			log.Println("Listening on TLS:", *addr+":"+Config.InternalScreenSharePort)
			go http.ListenAndServeTLS(*addr+":"+Config.InternalScreenSharePort, *certFile, *keyFile, server)
			time.Sleep(2 * time.Second)
		} else {
			log.Println("Listening:", *addr+":"+Config.InternalScreenSharePort)
			go http.ListenAndServe(*addr+":"+Config.InternalScreenSharePort, server)
			time.Sleep(2 * time.Second)
		}
	}

	// If both server selected set the remote Gameserver to local now.
	if *BothServers {
		if Config.DomainName == "" {
			Config.BackendURL = "http://" + Config.NATEscapeGameServerPort + "/"
		} else {
			Config.BackendURL = "https://" + Config.DomainName + "/"
		}
		err = Config.WriteConfig()
		if err != nil {
			fmt.Println(err)
			return
		}
	}

	// Running in headless mode
	if *headless {
		// Running starting a browser as a background process
		go func() {
			Config, err = config.ConfigInit()
			if err != nil {
				log.Fatalln(err)
			}

			//// Returns the URl address type
			//Addr := Ip4or6(Config.IPAddress)
			//
			//// If address is provided
			//if *addr != "" {
			//    Addr = *addr
			//    // Add brackets if the ip address is ipv6
			//    Addr = Ip4or6(Addr)
			//}

			var TaskExecute string

			if *BinaryToExecute != "" {
				TaskExecute = *BinaryToExecute
			} else {
				// Read binary from config file
				TaskExecute = Config.ScriptToExecute
			}

			// Starting screen share headless
			cmd := exec.Command(Config.BrowserCommand, "--no-sandbox", "--auto-select-desktop-capture-source="+Config.ScreenName, "--url", "https://"+*addr+":"+Config.InternalScreenSharePort+"/?mode=headless", "--ignore-certificate-errors")
			if err := cmd.Start(); err != nil {
				log.Fatalln(err)
			}

			// Makes program sleep for 2 seconds to allow chromium browser to open
			time.Sleep(3 * time.Second)

			err = core.BroadcastServerToBackend()
			if err != nil {
				fmt.Println(err)
			} else {
				fmt.Println("success broadcasting to game server")
			}

			// Task to be executed
			err = RunTask(TaskExecute)
			if err != nil {
				fmt.Println(err)
				return
			}
		}()

	}

	for {

	}

	// Start P2PRC server
	//_, err = abstractions.Start()
	//if err != nil {
	//    return
	//}

}

// PrettyPrint print the contents of the obj (
// Reference: https://stackoverflow.com/questions/24512112/how-to-print-struct-variables-in-console
func PrettyPrint(data interface{}) {
	var p []byte
	//    var err := error
	p, err := json.MarshalIndent(data, "", "\t")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("%s \n", p)
}

// Ip4or6 Helper function to check if the IP address is IPV4 or
// IPV6 (https://socketloop.com/tutorials/golang-check-if-ip-address-is-version-4-or-6)
func Ip4or6(s string) string {
	for i := 0; i < len(s); i++ {
		switch s[i] {
		case '.':
			return s
		case ':':
			return "[" + s + "]"
		}
	}
	return "[" + s + "]"

}

func RunTask(task string) error {
	// Halts the process
	cmd := exec.Command("sh", task)
	if err := cmd.Start(); err != nil {
		return err
	}

	return nil
}