package repository

import (
	"context"
	"errors"
	"fmt"

	"github.com/jackc/pgx/v5"
	"github.com/prabhupadasays/spsays-bff/internal/model"
)

// ErrPostNotFound is returned by lookup methods when no row matches.
var ErrPostNotFound = errors.New("post not found")

// PostRepo wraps Postgres access for posts + post_images.
type PostRepo struct{ pg *Postgres }

func NewPostRepo(pg *Postgres) *PostRepo { return &PostRepo{pg: pg} }

// Create inserts a post + its images in a single transaction so we never
// end up with orphan images.
func (r *PostRepo) Create(ctx context.Context, userID, caption, sourceURL, sourceTitle string, imageURLs []string) (*model.Post, error) {
	tx, err := r.pg.Pool.Begin(ctx)
	if err != nil {
		return nil, fmt.Errorf("begin tx: %w", err)
	}
	defer func() { _ = tx.Rollback(ctx) }()

	p := &model.Post{}
	err = tx.QueryRow(ctx, `
		INSERT INTO posts (user_id, caption, source_url, source_title)
		VALUES ($1, $2, $3, $4)
		RETURNING id, user_id, caption, source_url, COALESCE(source_title, ''), created_at, updated_at`,
		userID, caption, sourceURL, sourceTitle,
	).Scan(&p.ID, &p.UserID, &p.Caption, &p.SourceURL, &p.SourceTitle, &p.CreatedAt, &p.UpdatedAt)
	if err != nil {
		return nil, fmt.Errorf("insert post: %w", err)
	}

	for i, url := range imageURLs {
		var img model.PostImage
		err = tx.QueryRow(ctx, `
			INSERT INTO post_images (post_id, url, position)
			VALUES ($1, $2, $3)
			RETURNING id, url, position`,
			p.ID, url, i,
		).Scan(&img.ID, &img.URL, &img.Position)
		if err != nil {
			return nil, fmt.Errorf("insert post image %d: %w", i, err)
		}
		p.Images = append(p.Images, img)
	}

	if err := tx.Commit(ctx); err != nil {
		return nil, fmt.Errorf("commit: %w", err)
	}
	return p, nil
}

// ReplaceImages atomically swaps a post's image set. Ownership is
// enforced inside the tx by locking the post row and checking user_id —
// non-owners get ErrPostNotFound (we don't distinguish "not yours" from
// "doesn't exist" to non-owners). Existing rows are wiped, the new URLs
// are inserted with sequential positions, and the post's `updated_at`
// is touched so list views can sort by recency if needed later.
func (r *PostRepo) ReplaceImages(ctx context.Context, postID, userID string, imageURLs []string) error {
	tx, err := r.pg.Pool.Begin(ctx)
	if err != nil {
		return fmt.Errorf("begin tx: %w", err)
	}
	defer func() { _ = tx.Rollback(ctx) }()

	var owner string
	if err := tx.QueryRow(ctx, `SELECT user_id FROM posts WHERE id = $1 FOR UPDATE`, postID).Scan(&owner); err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return ErrPostNotFound
		}
		return fmt.Errorf("lock post: %w", err)
	}
	if owner != userID {
		return ErrPostNotFound
	}

	if _, err := tx.Exec(ctx, `DELETE FROM post_images WHERE post_id = $1`, postID); err != nil {
		return fmt.Errorf("delete images: %w", err)
	}
	for i, url := range imageURLs {
		if _, err := tx.Exec(ctx, `
			INSERT INTO post_images (post_id, url, position)
			VALUES ($1, $2, $3)`, postID, url, i,
		); err != nil {
			return fmt.Errorf("insert image %d: %w", i, err)
		}
	}
	if _, err := tx.Exec(ctx, `UPDATE posts SET updated_at = now() WHERE id = $1`, postID); err != nil {
		return fmt.Errorf("touch post: %w", err)
	}
	return tx.Commit(ctx)
}

// FindByID returns one post with its images and author info.
func (r *PostRepo) FindByID(ctx context.Context, id string) (*model.Post, error) {
	const q = `
		SELECT p.id, p.user_id, p.caption, p.source_url, COALESCE(p.source_title, ''),
		       p.created_at, p.updated_at, u.name, u.handle, u.avatar_url
		FROM posts p
		JOIN users u ON u.id = p.user_id
		WHERE p.id = $1`
	p := &model.Post{}
	err := r.pg.Pool.QueryRow(ctx, q, id).Scan(
		&p.ID, &p.UserID, &p.Caption, &p.SourceURL, &p.SourceTitle,
		&p.CreatedAt, &p.UpdatedAt,
		&p.AuthorName, &p.AuthorHandle, &p.AuthorAvatarURL,
	)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return nil, ErrPostNotFound
		}
		return nil, fmt.Errorf("find post: %w", err)
	}
	imgs, err := r.imagesFor(ctx, []string{p.ID})
	if err != nil {
		return nil, err
	}
	p.Images = imgs[p.ID]
	return p, nil
}

// ListByHandle returns the public feed for a user, newest-first, paginated.
func (r *PostRepo) ListByHandle(ctx context.Context, handle string, limit, offset int) ([]model.Post, int, error) {
	var total int
	if err := r.pg.Pool.QueryRow(ctx, `
		SELECT COUNT(*) FROM posts p
		JOIN users u ON u.id = p.user_id
		WHERE u.handle = $1`, handle,
	).Scan(&total); err != nil {
		return nil, 0, fmt.Errorf("count posts: %w", err)
	}

	const q = `
		SELECT p.id, p.user_id, p.caption, p.source_url, COALESCE(p.source_title, ''),
		       p.created_at, p.updated_at, u.name, u.handle, u.avatar_url
		FROM posts p
		JOIN users u ON u.id = p.user_id
		WHERE u.handle = $1
		ORDER BY p.created_at DESC
		LIMIT $2 OFFSET $3`
	return r.collectPosts(ctx, total, q, handle, limit, offset)
}

// ListByUser returns the user's own posts (private listing — same shape).
func (r *PostRepo) ListByUser(ctx context.Context, userID string, limit, offset int) ([]model.Post, int, error) {
	var total int
	if err := r.pg.Pool.QueryRow(ctx, `SELECT COUNT(*) FROM posts WHERE user_id = $1`, userID).Scan(&total); err != nil {
		return nil, 0, fmt.Errorf("count posts: %w", err)
	}
	const q = `
		SELECT p.id, p.user_id, p.caption, p.source_url, COALESCE(p.source_title, ''),
		       p.created_at, p.updated_at, u.name, u.handle, u.avatar_url
		FROM posts p
		JOIN users u ON u.id = p.user_id
		WHERE p.user_id = $1
		ORDER BY p.created_at DESC
		LIMIT $2 OFFSET $3`
	return r.collectPosts(ctx, total, q, userID, limit, offset)
}

// Delete removes a post only if it belongs to the caller.
func (r *PostRepo) Delete(ctx context.Context, postID, userID string) error {
	tag, err := r.pg.Pool.Exec(ctx,
		`DELETE FROM posts WHERE id = $1 AND user_id = $2`, postID, userID)
	if err != nil {
		return fmt.Errorf("delete post: %w", err)
	}
	if tag.RowsAffected() == 0 {
		return ErrPostNotFound
	}
	return nil
}

// CountByUser is used by services that need to know how many posts a user
// has — currently the public-profile endpoint only.
func (r *PostRepo) CountByUser(ctx context.Context, userID string) (int, error) {
	var n int
	err := r.pg.Pool.QueryRow(ctx, `SELECT COUNT(*) FROM posts WHERE user_id = $1`, userID).Scan(&n)
	if err != nil {
		return 0, fmt.Errorf("count user posts: %w", err)
	}
	return n, nil
}

// --- internal helpers ---

func (r *PostRepo) collectPosts(ctx context.Context, total int, query string, args ...any) ([]model.Post, int, error) {
	rows, err := r.pg.Pool.Query(ctx, query, args...)
	if err != nil {
		return nil, 0, fmt.Errorf("query posts: %w", err)
	}
	defer rows.Close()

	posts := []model.Post{}
	ids := []string{}
	for rows.Next() {
		var p model.Post
		if err := rows.Scan(
			&p.ID, &p.UserID, &p.Caption, &p.SourceURL, &p.SourceTitle,
			&p.CreatedAt, &p.UpdatedAt,
			&p.AuthorName, &p.AuthorHandle, &p.AuthorAvatarURL,
		); err != nil {
			return nil, 0, fmt.Errorf("scan post: %w", err)
		}
		posts = append(posts, p)
		ids = append(ids, p.ID)
	}
	if err := rows.Err(); err != nil {
		return nil, 0, fmt.Errorf("iterate posts: %w", err)
	}

	if len(ids) > 0 {
		imgs, err := r.imagesFor(ctx, ids)
		if err != nil {
			return nil, 0, err
		}
		for i := range posts {
			posts[i].Images = imgs[posts[i].ID]
		}
	}
	return posts, total, nil
}

// imagesFor returns a map post_id → [images...] for a batch of post IDs in
// a single query so we don't N+1 the feed endpoint.
func (r *PostRepo) imagesFor(ctx context.Context, postIDs []string) (map[string][]model.PostImage, error) {
	out := make(map[string][]model.PostImage, len(postIDs))
	if len(postIDs) == 0 {
		return out, nil
	}
	rows, err := r.pg.Pool.Query(ctx, `
		SELECT post_id, id, url, position
		FROM post_images
		WHERE post_id = ANY($1)
		ORDER BY post_id, position`, postIDs,
	)
	if err != nil {
		return nil, fmt.Errorf("query post images: %w", err)
	}
	defer rows.Close()
	for rows.Next() {
		var postID string
		var img model.PostImage
		if err := rows.Scan(&postID, &img.ID, &img.URL, &img.Position); err != nil {
			return nil, fmt.Errorf("scan post image: %w", err)
		}
		out[postID] = append(out[postID], img)
	}
	return out, rows.Err()
}