package main

import (
	"context"
	"os"
	"os/signal"
	"syscall"
	"time"

	"dev.mediocregopher.com/mediocre-blog.git/src/cache"
	cfgpkg "dev.mediocregopher.com/mediocre-blog.git/src/cfg"
	"dev.mediocregopher.com/mediocre-blog.git/src/gmi"
	"dev.mediocregopher.com/mediocre-blog.git/src/http"
	"dev.mediocregopher.com/mediocre-blog.git/src/post"
	"dev.mediocregopher.com/mediocre-blog.git/src/post/asset"
	"dev.mediocregopher.com/mediocre-go-lib.git/mctx"
	"dev.mediocregopher.com/mediocre-go-lib.git/mlog"
)

func main() {

	ctx := context.Background()

	cfg := cfgpkg.NewBlogCfg(cfgpkg.Params{})

	var dataDir cfgpkg.DataDir
	dataDir.SetupCfg(cfg)
	defer dataDir.Close()
	ctx = mctx.WithAnnotator(ctx, &dataDir)

	var httpParams http.Params
	httpParams.SetupCfg(cfg)
	ctx = mctx.WithAnnotator(ctx, &httpParams)

	var gmiParams gmi.Params
	gmiParams.SetupCfg(cfg)
	ctx = mctx.WithAnnotator(ctx, &gmiParams)

	// initialization
	err := cfg.Init(ctx)

	logger := mlog.NewLogger(nil)
	defer logger.Close()

	logger.Info(ctx, "process started")
	defer logger.Info(ctx, "process exiting")

	if err != nil {
		logger.Fatal(ctx, "initializing", err)
	}

	postSQLDB, err := post.NewSQLDB(dataDir)
	if err != nil {
		logger.Fatal(ctx, "initializing sql db for post data", err)
	}
	defer postSQLDB.Close()

	postStore := post.NewStore(postSQLDB)

	postAssetStore := asset.NewStore(postSQLDB)

	postAssetLoader := asset.NewStoreLoader(postAssetStore)
	postAssetLoader = asset.NewArchiveLoader(postAssetLoader)
	postAssetLoader = asset.NewImageLoader(postAssetLoader)

	postDraftStore := post.NewDraftStore(postSQLDB)

	cache := cache.New(5000)

	httpParams.Logger = logger.WithNamespace("http")
	httpParams.Cache = cache
	httpParams.PostStore = postStore
	httpParams.PostAssetStore = postAssetStore
	httpParams.PostAssetLoader = postAssetLoader
	httpParams.PostDraftStore = postDraftStore
	httpParams.GeminiPublicURL = gmiParams.PublicURL

	logger.Info(ctx, "starting http api")
	httpAPI, err := http.New(httpParams)
	if err != nil {
		logger.Fatal(ctx, "starting http api", err)
	}
	defer func() {
		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
		defer cancel()

		if err := httpAPI.Shutdown(shutdownCtx); err != nil {
			logger.Fatal(ctx, "shutting down http api", err)
		}
	}()

	gmiParams.Logger = logger.WithNamespace("gmi")
	gmiParams.Cache = cache
	gmiParams.PostStore = postStore
	gmiParams.PostAssetLoader = postAssetLoader
	gmiParams.HTTPPublicURL = httpParams.PublicURL
	gmiParams.HTTPGeminiGatewayURL = httpParams.GeminiGatewayURL

	logger.Info(ctx, "starting gmi api")
	gmiAPI, err := gmi.New(gmiParams)
	if err != nil {
		logger.Fatal(ctx, "starting gmi api", err)
	}

	defer func() {
		shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
		defer cancel()

		if err := gmiAPI.Shutdown(shutdownCtx); err != nil {
			logger.Fatal(ctx, "shutting down gmi api", err)
		}
	}()

	// wait

	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
	<-sigCh

	// let the defers begin
}