package main

import (
	"context"
	"encoding/json"
	"flag"
	"os"
	"os/signal"
	"path"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"

	"gitea.thegux.fr/hmdeploy/deployers"
	"gitea.thegux.fr/hmdeploy/docker"
	"gitea.thegux.fr/hmdeploy/models"
	"gitea.thegux.fr/hmdeploy/scheduler"
)

const HMDEPLOY_DIRNAME = ".homeserver"
const NETWORK_FILENAME = "map.json"

var HOME_PATH = os.Getenv("HOME")

func initLogger() {
	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
	log.Logger = log.With().Caller().Logger().Output(zerolog.ConsoleWriter{Out: os.Stderr})
}

func main() {
	ctx, stop := signal.NotifyContext(
		context.Background(),
		os.Interrupt,
		os.Kill,
	)
	defer stop()

	initLogger()
	log.Info().Msg("hmdeploy started")

	projectDir := flag.String("path", ".", "define the .homeserver project root dir")
	flag.Parse()

	hmmap_path := path.Join(HOME_PATH, HMDEPLOY_DIRNAME, NETWORK_FILENAME)
	c, err := os.ReadFile(hmmap_path)
	if err != nil {
		log.Fatal().Err(err).Str("conf", hmmap_path).Msg("unable to load configuration")
	}

	var hmmap models.HMMap
	if err := json.Unmarshal(c, &hmmap); err != nil {
		log.Fatal().Err(err).Str("conf", hmmap_path).Msg("unable to parse configuration")
	}
	log.Info().Str("conf", hmmap_path).Msg("hmmap load successfully")

	project, err := models.ProjectFromDir(*projectDir)
	if err != nil {
		log.Fatal().Str("dir", *projectDir).Err(err).Msg("unable to init project from directory")
	}
	log.Info().Str("dir", project.Dir).Str("name", project.Name).Msg("project initialized with success")

	swarmNet := hmmap.GetSwarmNetInfo()
	if swarmNet == nil {
		log.Fatal().Err(err).Msg("unable to get swarm net info, does not exist")
	}
	dcli := docker.NewClient()

	sd, err := deployers.NewSwarmDeployer(ctx, &dcli, swarmNet, &project)
	if err != nil {
		log.Fatal().Err(err).Msg("unable to init swarm deployer")
	}

	var nd deployers.IDeployer
	if project.Deps.NginxFile != "" {
		nginxNet := hmmap.GetNginxNetInfo()
		if nginxNet == nil {
			log.Err(err).Msg("unable to get nginx net info, does not exist")
			return
		}

		d, err := deployers.NewNginxDeployer(ctx, nginxNet, &project)
		if err != nil {
			log.Err(err).Msg("unable to nginx conf")
			return
		}

		nd = &d
	}

	deployNginx := scheduler.NewTask("nginx-deploy", nd.Deploy)
	deploySwarm := scheduler.NewTask("swarm-deploy", sd.Deploy, deployNginx)

	s := scheduler.NewScheduler(context.Background(), 30, 4)
	s.Submit(scheduler.NewTask("swarm-build", sd.Build, deploySwarm))
	s.Submit(scheduler.NewTask("nginx-build", nd.Build))

	<-nd.Done()
	<-sd.Done()

	s.Submit(scheduler.NewTask("nginx-clear", nd.Clear))
	s.Submit(scheduler.NewTask("swarm-clear", sd.Clear))

	s.Stop()
	<-s.Done()

	log.Info().Str("name", project.Name).Msg("project deployed successfully")
}