package dependencies

import (
	"log/slog"

	toolkitModel "git.nakama.town/fmartingr/gotoolkit/model"
	"git.nakama.town/fmartingr/hako/internal/archival/archiver"
	"git.nakama.town/fmartingr/hako/internal/archival/rules"
	archivalStore "git.nakama.town/fmartingr/hako/internal/archival/store"
	"git.nakama.town/fmartingr/hako/internal/auth"
	"git.nakama.town/fmartingr/hako/internal/auth/store"
	"git.nakama.town/fmartingr/hako/internal/config"
	"git.nakama.town/fmartingr/hako/internal/extractors"
	"git.nakama.town/fmartingr/hako/internal/model"
)

// Dependencies holds all application dependencies
type Dependencies struct {
	log      *slog.Logger
	config   *config.Config
	database toolkitModel.DB
	domains  *domains

	// Stores
	LinkStore           *archivalStore.LinkStore
	ArchiveStore        *archivalStore.ArchiveStore
	ArchiveFileStore    *archivalStore.ArchiveFileStore
	LinkCategoryStore   *archivalStore.LinkCategoryStore
	CategoryStore       *archivalStore.CategoryStore
	ArchiverConfigStore *archivalStore.ArchiverConfigStore
	SettingsStore       *archivalStore.SettingsStore
	UserStore           *store.UserStore

	// Other dependencies
	Storage      model.Storage
	Queue        model.Queue
	ArchiverMgr  *archiver.Manager
	ExtractorMgr *extractors.Manager
	RuleEngine   *rules.Engine
	JWTService   *auth.JWTService
}

func (d *Dependencies) Logger() *slog.Logger {
	return d.log
}

func (d *Dependencies) Config() *config.Config {
	return d.config
}

func (d *Dependencies) Database() toolkitModel.DB {
	return d.database
}

func (d *Dependencies) Domains() model.DomainDependencies {
	return d.domains
}

func (d *Dependencies) GetJWTService() *auth.JWTService {
	return d.JWTService
}

type domains struct {
	links      model.LinkDomain
	archives   model.ArchiveDomain
	categories model.CategoryDomain
	auth       model.AuthDomain
}

func (d *domains) Links() model.LinkDomain {
	return d.links
}

func (d *domains) SetLinks(links model.LinkDomain) {
	d.links = links
}

func (d *domains) Archives() model.ArchiveDomain {
	return d.archives
}

func (d *domains) SetArchives(archives model.ArchiveDomain) {
	d.archives = archives
}

func (d *domains) Categories() model.CategoryDomain {
	return d.categories
}

func (d *domains) SetCategories(categories model.CategoryDomain) {
	d.categories = categories
}

func (d *domains) Auth() model.AuthDomain {
	return d.auth
}

func (d *domains) SetAuth(auth model.AuthDomain) {
	d.auth = auth
}

var _ model.DomainDependencies = (*domains)(nil)

// NewDependencies creates a new Dependencies instance
func NewDependencies(log *slog.Logger, db toolkitModel.DB, cfg *config.Config) *Dependencies {
	return &Dependencies{
		log:      log,
		config:   cfg,
		database: db,
		domains:  &domains{},
	}
}