package main

import (
	"crypto"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/url"
	"os"

	"crispbyte.dev/sig-auth/client"
	"crispbyte.dev/sig-auth/keydirectory"
	"crispbyte.dev/sig-auth/server"
	"golang.org/x/crypto/ssh"
)

func main() {
	useClient := flag.Bool("c", false, "Run client")
	keyId := flag.String("id", "", "The key id to pass")
	register := flag.Bool("r", false, "Register a key")
	user := flag.String("user", "", "Username to register")
	keyPath := flag.String("key", "", "Path to the private key (client mode) or public key (registration mode) to use")
	baseUrlString := flag.String("base-url", "http://localhost:8001", "Base URL of the server")
	useTempDb := flag.Bool("temp-db", false, "Use a temporary in-memory database")
	dbPath := flag.String("db", "", "Path to the sqlite database file")

	flag.Parse()

	baseUrl, err := url.Parse(*baseUrlString)

	if err != nil {
		flag.PrintDefaults()
		return
	}

	if *useClient {
		if *keyPath == "" || *keyId == "" {
			flag.PrintDefaults()
			return
		}

		runClient(baseUrl, *keyPath, *keyId)
	} else if *register {
		if *keyPath == "" || *user == "" {
			flag.PrintDefaults()
			return
		}

		registerKey(baseUrl, *keyPath, *user)
	} else {
		if !*useTempDb && *dbPath == "" {
			flag.PrintDefaults()
			return
		}

		runServer(*useTempDb, *dbPath)
	}
}

func runClient(baseUrl *url.URL, keyFile string, keyId string) {
	testData := map[string]string{"hello": "world"}
	json_data, _ := json.Marshal(testData)

	key, err := loadPrivateKey(keyFile)

	if err != nil {
		log.Fatal(err)
	}

	resp, err := client.Post(baseUrl, key, keyId, json_data)

	if err != nil {
		log.Fatal(err)
	}

	defer resp.Body.Close()

	out, err := io.ReadAll(resp.Body)

	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(resp.StatusCode)
	fmt.Println(resp.Header)
	fmt.Println(string(out[:]))
}

func loadPrivateKey(keyFile string) (crypto.PrivateKey, error) {
	keyBytes, err := os.ReadFile(keyFile)

	if err != nil {
		return nil, err
	}

	return ssh.ParseRawPrivateKey(keyBytes)
}

func registerKey(baseUrl *url.URL, keyFile string, userId string) {
	keyBytes, err := os.ReadFile(keyFile)

	if err != nil {
		log.Fatal(err)
	}

	keyText := string(keyBytes)

	keyId, err := client.RegisterKey(baseUrl, keyText, userId)

	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Registered key id: %s\n", keyId)
}

func runServer(useTempDb bool, dbPath string) {
	var keyDir keydirectory.RegistrationDirectory

	if useTempDb {
		keyDir = keydirectory.CreateMemoryDirectory()
	} else {
		var err error
		keyDir, err = keydirectory.InitSqlite(dbPath)

		if err != nil {
			log.Fatal(err)
		}
	}

	server.Start(keyDir)
}