// Package database provides SQLite database access.
package database

import (
	"context"
	"database/sql"
	"log/slog"

	"go.uber.org/fx"
	"sneak.berlin/go/pixa/internal/config"
	"sneak.berlin/go/pixa/internal/logger"

	_ "modernc.org/sqlite" // SQLite driver registration
)

// Params defines dependencies for Database.
type Params struct {
	fx.In
	Logger *logger.Logger
	Config *config.Config
}

// Database wraps the SQL database connection.
type Database struct {
	db     *sql.DB
	log    *slog.Logger
	config *config.Config
}

// New creates a new Database instance.
func New(lc fx.Lifecycle, params Params) (*Database, error) {
	s := &Database{
		log:    params.Logger.Get(),
		config: params.Config,
	}

	s.log.Info("Database instantiated")

	lc.Append(fx.Hook{
		OnStart: func(ctx context.Context) error {
			s.log.Info("Database OnStart Hook")

			return s.connect(ctx)
		},
		OnStop: func(_ context.Context) error {
			s.log.Info("Database OnStop Hook")
			if s.db != nil {
				return s.db.Close()
			}

			return nil
		},
	})

	return s, nil
}

func (s *Database) connect(ctx context.Context) error {
	dbURL := s.config.DBURL

	s.log.Info("connecting to database", "url", dbURL)

	db, err := sql.Open("sqlite", dbURL)
	if err != nil {
		s.log.Error("failed to open database", "error", err)

		return err
	}

	if err := db.PingContext(ctx); err != nil {
		s.log.Error("failed to ping database", "error", err)

		return err
	}

	s.db = db
	s.log.Info("database connected")

	return s.createSchema(ctx)
}

func (s *Database) createSchema(ctx context.Context) error {
	// FIXME: Add actual schema for cache metadata
	schema := `
	CREATE TABLE IF NOT EXISTS cache_metadata (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		source_url TEXT NOT NULL UNIQUE,
		source_hash TEXT NOT NULL,
		content_type TEXT,
		fetched_at DATETIME DEFAULT CURRENT_TIMESTAMP,
		expires_at DATETIME,
		created_at DATETIME DEFAULT CURRENT_TIMESTAMP
	);
	CREATE INDEX IF NOT EXISTS idx_cache_source_url ON cache_metadata(source_url);
	CREATE INDEX IF NOT EXISTS idx_cache_source_hash ON cache_metadata(source_hash);
	`

	_, err := s.db.ExecContext(ctx, schema)
	if err != nil {
		s.log.Error("failed to create schema", "error", err)

		return err
	}

	s.log.Info("database schema initialized")

	return nil
}

// DB returns the underlying sql.DB.
func (s *Database) DB() *sql.DB {
	return s.db
}