package main

import (
	"fmt"
	"io"
	"log"
	"path/filepath"
	"strings"

	"git.nevets.tech/Steven/ezconf"
	"github.com/go-git/go-billy/v5/memfs"
	"github.com/go-git/go-git/v5/storage/memory"
)

func initClient() {
	err := loadDomainConfigs()
	if err != nil {
		log.Fatalf("Error loading domain configs: %v", err)
	}
}

func clientTick() {
	fmt.Println("Tick!")

	mu.RLock()
	localDomainConfigs := make(map[string]*ezconf.Configuration, len(domainConfigs))
	for k, v := range domainConfigs {
		localDomainConfigs[k] = v
	}
	mu.RUnlock()

	for domainStr, domainConfig := range localDomainConfigs {
		if !domainConfig.GetAsBoolean("Domain.enabled") {
			continue
		}

		gitWorkspace := &GitWorkspace{
			Storage: memory.NewStorage(),
			FS:      memfs.New(),
		}
		repoUrl := config.GetAsString("Git.server") + "/" + config.GetAsString("Git.org_name") + "/" + domainStr + domainConfig.GetAsString("Repo.repo_suffix") + ".git"
		err := cloneRepo(repoUrl, gitWorkspace)
		if err != nil {
			fmt.Printf("Error cloning domain repo %s: %v\n", domainStr, err)
			continue
		}

		fileInfos, err := gitWorkspace.FS.ReadDir("/")
		if err != nil {
			fmt.Printf("Error reading directory in memFS on domain %s: %v\n", domainStr, err)
			continue
		}
		for _, fileInfo := range fileInfos {
			if strings.HasSuffix(fileInfo.Name(), ".crpt") {
				filename, _ := strings.CutSuffix(fileInfo.Name(), ".crpt")
				file, err := gitWorkspace.FS.Open(fileInfo.Name())
				if err != nil {
					fmt.Printf("Error opening file in memFS on domain %s: %v\n", domainStr, err)
					continue
				}

				fileBytes, err := io.ReadAll(file)
				if err != nil {
					fmt.Printf("Error reading file in memFS on domain %s: %v\n", domainStr, err)
					file.Close()
					continue
				}
				err = file.Close()
				if err != nil {
					fmt.Printf("Error closing file on domain %s: %v\n", domainStr, err)
					continue
				}

				dataRoot, err := getEffectiveString(domainConfig, "Certificates.data_root")
				if err != nil {
					fmt.Printf("Error getting effective data_root for domain %s: %v\n", domainStr, err)
					continue
				}
				err = DecryptFileFromBytes(domainConfig.GetAsString("Certificates.crypto_key"), fileBytes, filepath.Join(dataRoot, "certificates", domainStr, filename), nil)
				if err != nil {
					fmt.Printf("Error decrypting file %s in domain %s: %v\n", filename, domainStr, err)
					continue
				}

				//TODO write hash locally, compare on tick to determine update
			}
		}
	}
}

func reloadClient() {
	fmt.Println("Reloading configs...")

	err := loadDomainConfigs()
	if err != nil {
		fmt.Printf("Error loading domain configs: %v\n", err)
		return
	}
}

func stopClient() {
	fmt.Println("Shutting down client")
}