package savedrecipe

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

	"github.com/food-ai/backend/internal/locale"
	"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 and their translations.
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.
// The canonical content (any language) is stored directly in saved_recipes.
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.
// Text content (title, description, ingredients, steps) is resolved for the
// language stored in ctx, falling back to the canonical content when no
// translation exists.
func (r *Repository) List(ctx context.Context, userID string) ([]*SavedRecipe, error) {
	lang := locale.FromContext(ctx)
	const query = `
		SELECT sr.id, sr.user_id,
			COALESCE(srt.title,       sr.title)       AS title,
			COALESCE(srt.description, sr.description) AS description,
			sr.cuisine, sr.difficulty,
			sr.prep_time_min, sr.cook_time_min, sr.servings, sr.image_url,
			COALESCE(srt.ingredients, sr.ingredients) AS ingredients,
			COALESCE(srt.steps,       sr.steps)       AS steps,
			sr.tags, sr.nutrition, sr.source, sr.saved_at
		FROM saved_recipes sr
		LEFT JOIN saved_recipe_translations srt
		       ON srt.saved_recipe_id = sr.id AND srt.lang = $2
		WHERE sr.user_id = $1
		ORDER BY sr.saved_at DESC`

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

	var result []*SavedRecipe
	for rows.Next() {
		rec, err := scanRow(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.
// Text content is resolved for the language stored in ctx.
func (r *Repository) GetByID(ctx context.Context, userID, id string) (*SavedRecipe, error) {
	lang := locale.FromContext(ctx)
	const query = `
		SELECT sr.id, sr.user_id,
			COALESCE(srt.title,       sr.title)       AS title,
			COALESCE(srt.description, sr.description) AS description,
			sr.cuisine, sr.difficulty,
			sr.prep_time_min, sr.cook_time_min, sr.servings, sr.image_url,
			COALESCE(srt.ingredients, sr.ingredients) AS ingredients,
			COALESCE(srt.steps,       sr.steps)       AS steps,
			sr.tags, sr.nutrition, sr.source, sr.saved_at
		FROM saved_recipes sr
		LEFT JOIN saved_recipe_translations srt
		       ON srt.saved_recipe_id = sr.id AND srt.lang = $3
		WHERE sr.id = $1 AND sr.user_id = $2`

	rec, err := scanRow(r.pool.QueryRow(ctx, query, id, userID, lang))
	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
}

// UpsertTranslation inserts or replaces a translation for a saved recipe.
func (r *Repository) UpsertTranslation(
	ctx context.Context,
	id, lang string,
	title, description *string,
	ingredients, steps json.RawMessage,
) error {
	const query = `
		INSERT INTO saved_recipe_translations (saved_recipe_id, lang, title, description, ingredients, steps)
		VALUES ($1, $2, $3, $4, $5, $6)
		ON CONFLICT (saved_recipe_id, lang) DO UPDATE SET
			title        = EXCLUDED.title,
			description  = EXCLUDED.description,
			ingredients  = EXCLUDED.ingredients,
			steps        = EXCLUDED.steps,
			generated_at = now()`

	if _, err := r.pool.Exec(ctx, query, id, lang, title, description, ingredients, steps); err != nil {
		return fmt.Errorf("upsert saved recipe translation %s/%s: %w", id, lang, err)
	}
	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
}

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
}