package savedrecipe

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"
)

// ErrNotFound is returned when a saved recipe does not exist for the given user.
var ErrNotFound = errors.New("saved recipe not found")

// Repository handles persistence for saved recipes.
type Repository struct {
	pool *pgxpool.Pool
}

// NewRepository creates a new Repository.
func NewRepository(pool *pgxpool.Pool) *Repository {
	return &Repository{pool: pool}
}

// Save persists a recipe for userID and returns the stored record.
func (r *Repository) Save(ctx context.Context, userID string, req SaveRequest) (*SavedRecipe, error) {
	const query = `
		INSERT INTO saved_recipes (
			user_id, title, description, cuisine, difficulty,
			prep_time_min, cook_time_min, servings, image_url,
			ingredients, steps, tags, nutrition, source
		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
		RETURNING id, user_id, title, description, cuisine, difficulty,
			prep_time_min, cook_time_min, servings, image_url,
			ingredients, steps, tags, nutrition, source, saved_at`

	description := nullableStr(req.Description)
	cuisine := nullableStr(req.Cuisine)
	difficulty := nullableStr(req.Difficulty)
	imageURL := nullableStr(req.ImageURL)
	prepTime := nullableInt(req.PrepTimeMin)
	cookTime := nullableInt(req.CookTimeMin)
	servings := nullableInt(req.Servings)

	source := req.Source
	if source == "" {
		source = "ai"
	}

	ingredients := defaultJSONArray(req.Ingredients)
	steps := defaultJSONArray(req.Steps)
	tags := defaultJSONArray(req.Tags)

	row := r.pool.QueryRow(ctx, query,
		userID, req.Title, description, cuisine, difficulty,
		prepTime, cookTime, servings, imageURL,
		ingredients, steps, tags, req.Nutrition, source,
	)
	return scanRow(row)
}

// List returns all saved recipes for userID ordered by saved_at DESC.
func (r *Repository) List(ctx context.Context, userID string) ([]*SavedRecipe, error) {
	const query = `
		SELECT id, user_id, title, description, cuisine, difficulty,
			prep_time_min, cook_time_min, servings, image_url,
			ingredients, steps, tags, nutrition, source, saved_at
		FROM saved_recipes
		WHERE user_id = $1
		ORDER BY saved_at DESC`

	rows, err := r.pool.Query(ctx, query, userID)
	if err != nil {
		return nil, fmt.Errorf("list saved recipes: %w", err)
	}
	defer rows.Close()

	var result []*SavedRecipe
	for rows.Next() {
		rec, err := scanRows(rows)
		if err != nil {
			return nil, fmt.Errorf("scan saved recipe: %w", err)
		}
		result = append(result, rec)
	}
	return result, rows.Err()
}

// GetByID returns the saved recipe with id for userID, or nil if not found.
func (r *Repository) GetByID(ctx context.Context, userID, id string) (*SavedRecipe, error) {
	const query = `
		SELECT id, user_id, title, description, cuisine, difficulty,
			prep_time_min, cook_time_min, servings, image_url,
			ingredients, steps, tags, nutrition, source, saved_at
		FROM saved_recipes
		WHERE id = $1 AND user_id = $2`

	rec, err := scanRow(r.pool.QueryRow(ctx, query, id, userID))
	if errors.Is(err, pgx.ErrNoRows) {
		return nil, nil
	}
	return rec, err
}

// Delete removes the saved recipe with id for userID.
// Returns ErrNotFound if the record does not exist.
func (r *Repository) Delete(ctx context.Context, userID, id string) error {
	tag, err := r.pool.Exec(ctx,
		`DELETE FROM saved_recipes WHERE id = $1 AND user_id = $2`,
		id, userID,
	)
	if err != nil {
		return fmt.Errorf("delete saved recipe: %w", err)
	}
	if tag.RowsAffected() == 0 {
		return ErrNotFound
	}
	return nil
}

// --- helpers ---

type scannable interface {
	Scan(dest ...any) error
}

func scanRow(s scannable) (*SavedRecipe, error) {
	var rec SavedRecipe
	var ingredients, steps, tags, nutrition []byte
	err := s.Scan(
		&rec.ID, &rec.UserID, &rec.Title, &rec.Description, &rec.Cuisine, &rec.Difficulty,
		&rec.PrepTimeMin, &rec.CookTimeMin, &rec.Servings, &rec.ImageURL,
		&ingredients, &steps, &tags, &nutrition,
		&rec.Source, &rec.SavedAt,
	)
	if err != nil {
		return nil, err
	}
	rec.Ingredients = json.RawMessage(ingredients)
	rec.Steps = json.RawMessage(steps)
	rec.Tags = json.RawMessage(tags)
	if len(nutrition) > 0 {
		rec.Nutrition = json.RawMessage(nutrition)
	}
	return &rec, nil
}

// scanRows wraps pgx.Rows to satisfy the scannable interface.
func scanRows(rows pgx.Rows) (*SavedRecipe, error) {
	return scanRow(rows)
}

func nullableStr(s string) *string {
	if s == "" {
		return nil
	}
	return &s
}

func nullableInt(n int) *int {
	if n <= 0 {
		return nil
	}
	return &n
}

func defaultJSONArray(raw json.RawMessage) json.RawMessage {
	if len(raw) == 0 {
		return json.RawMessage(`[]`)
	}
	return raw
}