package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"log/slog"
	"os"
	"os/signal"

	"git.amiirkhl.ir/starcoach-hackathon/zarinpal-analytics-backend/internal/config"
	"git.amiirkhl.ir/starcoach-hackathon/zarinpal-analytics-backend/internal/database"
	"git.amiirkhl.ir/starcoach-hackathon/zarinpal-analytics-backend/internal/eventcatalog"
	"git.amiirkhl.ir/starcoach-hackathon/zarinpal-analytics-backend/internal/insight"
)

func main() {
	action := flag.String("action", "", "import, approve, or activate")
	filePath := flag.String("file", "", "reviewed JSON catalog for import")
	version := flag.String("version", "", "catalog version for approve or activate")
	actor := flag.String("actor", "", "audited reviewer or operator identity")
	currentJalaliYear := flag.Int("current-jalali-year", 0, "current Jalali year used for coverage validation")
	flag.Parse()

	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
	defer cancel()
	cfg, err := config.Load()
	if err != nil {
		fail(logger, "configuration failed", err)
	}
	pool, err := database.Open(ctx, cfg.DatabaseURL)
	if err != nil {
		fail(logger, "database connection failed", err)
	}
	defer pool.Close()
	repository := eventcatalog.NewRepository(pool)

	switch *action {
	case "import":
		if *filePath == "" || *currentJalaliYear == 0 {
			fail(logger, "invalid import arguments", fmt.Errorf("file and current-jalali-year are required"))
		}
		file, err := os.Open(*filePath)
		if err != nil {
			fail(logger, "opening calendar catalog failed", err)
		}
		defer file.Close()
		var input eventcatalog.Import
		decoder := json.NewDecoder(file)
		decoder.DisallowUnknownFields()
		if err := decoder.Decode(&input); err != nil {
			fail(logger, "decoding calendar catalog failed", err)
		}
		if err := eventcatalog.ValidateImport(input, *currentJalaliYear); err != nil {
			fail(logger, "calendar validation failed", err)
		}
		if err := repository.ImportDraft(ctx, input); err != nil {
			fail(logger, "calendar import failed", err)
		}
		logger.Info("calendar draft imported", "version", input.Version, "events", len(input.Events))
	case "approve":
		if *version == "" || *actor == "" {
			fail(logger, "invalid approval arguments", fmt.Errorf("version and actor are required"))
		}
		if err := repository.Approve(ctx, *version, *actor); err != nil {
			fail(logger, "calendar approval failed", err)
		}
		logger.Info("calendar approved", "version", *version, "reviewer", *actor)
	case "activate":
		if *version == "" || *actor == "" {
			fail(logger, "invalid activation arguments", fmt.Errorf("version and actor are required"))
		}
		if err := repository.Activate(ctx, *version, *actor); err != nil {
			fail(logger, "calendar activation failed", err)
		}
		service := insight.NewService(insight.NewRepository(pool), insight.NewPostgreSQLBuilder(pool))
		created, err := service.EnqueueAll(ctx, "CALENDAR")
		if err != nil {
			fail(logger, "calendar refresh scheduling failed", err)
		}
		logger.Info("calendar activated", "version", *version, "actor", *actor, "created_jobs", created)
	default:
		fail(logger, "invalid action", fmt.Errorf("action must be import, approve, or activate"))
	}
}

func fail(logger *slog.Logger, message string, err error) {
	logger.Error(message, "error", err)
	os.Exit(1)
}