package repository

import (
	"context"
	"errors"
	"fmt"

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

// social_graph_repo.go bundles the four small repos backing the social
// graph — follows, blocks, reports, and notifications. Each is a thin
// wrapper over the shared Postgres pool, mirroring the per-domain repo
// convention used elsewhere (UserRepo, PostRepo, …). They're grouped in
// one file because each is only a handful of queries and they share the
// same dependency.

// ---------------------------------------------------------------------------
// FollowRepo
// ---------------------------------------------------------------------------

// FollowRepo manages the request-based follows edge table.
type FollowRepo struct{ pg *Postgres }

func NewFollowRepo(pg *Postgres) *FollowRepo { return &FollowRepo{pg: pg} }

// Request inserts a pending follow edge follower→following. Idempotent:
// a repeated request (the edge already exists, pending or accepted) is a
// no-op. Returns created=true only when a brand-new pending row was
// inserted, so the caller fires the "X requested to follow you"
// notification exactly once.
func (r *FollowRepo) Request(ctx context.Context, followerID, followingID string) (created bool, err error) {
	tag, err := r.pg.Pool.Exec(ctx, `
		INSERT INTO follows (follower_id, following_id, status)
		VALUES ($1, $2, 'pending')
		ON CONFLICT (follower_id, following_id) DO NOTHING`,
		followerID, followingID,
	)
	if err != nil {
		return false, fmt.Errorf("request follow: %w", err)
	}
	return tag.RowsAffected() == 1, nil
}

// Accept flips a pending edge follower→following to accepted and stamps
// responded_at. Returns accepted=true only on the transition from
// pending (so the "X accepted your request" notification fires once); a
// call on an already-accepted or absent edge returns false.
func (r *FollowRepo) Accept(ctx context.Context, followerID, followingID string) (accepted bool, err error) {
	tag, err := r.pg.Pool.Exec(ctx, `
		UPDATE follows
		SET status = 'accepted', responded_at = now()
		WHERE follower_id = $1 AND following_id = $2 AND status = 'pending'`,
		followerID, followingID,
	)
	if err != nil {
		return false, fmt.Errorf("accept follow: %w", err)
	}
	return tag.RowsAffected() == 1, nil
}

// Delete removes the edge follower→following regardless of status. Backs
// unfollow (accepted), cancel-request (own pending outgoing), reject
// (their pending incoming), and remove-follower (their accepted edge to
// me). Idempotent.
func (r *FollowRepo) Delete(ctx context.Context, followerID, followingID string) error {
	_, err := r.pg.Pool.Exec(ctx, `
		DELETE FROM follows WHERE follower_id = $1 AND following_id = $2`,
		followerID, followingID,
	)
	if err != nil {
		return fmt.Errorf("delete follow: %w", err)
	}
	return nil
}

// Status returns the status of the edge follower→following ('pending' or
// 'accepted'), or "" when no edge exists.
func (r *FollowRepo) Status(ctx context.Context, followerID, followingID string) (string, error) {
	var status string
	err := r.pg.Pool.QueryRow(ctx, `
		SELECT status FROM follows WHERE follower_id = $1 AND following_id = $2`,
		followerID, followingID,
	).Scan(&status)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return "", nil
		}
		return "", fmt.Errorf("follow status: %w", err)
	}
	return status, nil
}

// CountFollowers counts accepted edges pointing at userID.
func (r *FollowRepo) CountFollowers(ctx context.Context, userID string) (int, error) {
	var n int
	err := r.pg.Pool.QueryRow(ctx, `
		SELECT count(*) FROM follows WHERE following_id = $1 AND status = 'accepted'`,
		userID,
	).Scan(&n)
	if err != nil {
		return 0, fmt.Errorf("count followers: %w", err)
	}
	return n, nil
}

// CountFollowing counts accepted edges originating from userID.
func (r *FollowRepo) CountFollowing(ctx context.Context, userID string) (int, error) {
	var n int
	err := r.pg.Pool.QueryRow(ctx, `
		SELECT count(*) FROM follows WHERE follower_id = $1 AND status = 'accepted'`,
		userID,
	).Scan(&n)
	if err != nil {
		return 0, fmt.Errorf("count following: %w", err)
	}
	return n, nil
}

// ---------------------------------------------------------------------------
// BlockRepo
// ---------------------------------------------------------------------------

// BlockRepo manages user_blocks. Block() also tears down any follow
// edges in either direction, so it runs in a transaction.
type BlockRepo struct{ pg *Postgres }

func NewBlockRepo(pg *Postgres) *BlockRepo { return &BlockRepo{pg: pg} }

// Block records blocker→blocked (idempotent) and, in the same tx, deletes
// any follow edges between the two in either direction — blocking someone
// should sever the relationship both ways.
func (r *BlockRepo) Block(ctx context.Context, blockerID, blockedID string) error {
	tx, err := r.pg.Pool.Begin(ctx)
	if err != nil {
		return fmt.Errorf("begin block tx: %w", err)
	}
	defer tx.Rollback(ctx)

	if _, err := tx.Exec(ctx, `
		INSERT INTO user_blocks (blocker_id, blocked_id)
		VALUES ($1, $2)
		ON CONFLICT (blocker_id, blocked_id) DO NOTHING`,
		blockerID, blockedID,
	); err != nil {
		return fmt.Errorf("insert block: %w", err)
	}
	if _, err := tx.Exec(ctx, `
		DELETE FROM follows
		WHERE (follower_id = $1 AND following_id = $2)
		   OR (follower_id = $2 AND following_id = $1)`,
		blockerID, blockedID,
	); err != nil {
		return fmt.Errorf("sever follows on block: %w", err)
	}
	if err := tx.Commit(ctx); err != nil {
		return fmt.Errorf("commit block: %w", err)
	}
	return nil
}

// Unblock removes the blocker→blocked record. Idempotent.
func (r *BlockRepo) Unblock(ctx context.Context, blockerID, blockedID string) error {
	_, err := r.pg.Pool.Exec(ctx, `
		DELETE FROM user_blocks WHERE blocker_id = $1 AND blocked_id = $2`,
		blockerID, blockedID,
	)
	if err != nil {
		return fmt.Errorf("unblock: %w", err)
	}
	return nil
}

// BlockState reports, in one round-trip, whether a blocked b and whether
// b blocked a.
func (r *BlockRepo) BlockState(ctx context.Context, a, b string) (aBlockedB, bBlockedA bool, err error) {
	err = r.pg.Pool.QueryRow(ctx, `
		SELECT
			EXISTS(SELECT 1 FROM user_blocks WHERE blocker_id = $1 AND blocked_id = $2),
			EXISTS(SELECT 1 FROM user_blocks WHERE blocker_id = $2 AND blocked_id = $1)`,
		a, b,
	).Scan(&aBlockedB, &bBlockedA)
	if err != nil {
		return false, false, fmt.Errorf("block state: %w", err)
	}
	return aBlockedB, bBlockedA, nil
}

// ---------------------------------------------------------------------------
// ReportRepo
// ---------------------------------------------------------------------------

// ReportRepo manages user_reports.
type ReportRepo struct{ pg *Postgres }

func NewReportRepo(pg *Postgres) *ReportRepo { return &ReportRepo{pg: pg} }

// Create inserts a user-report row.
func (r *ReportRepo) Create(ctx context.Context, reporterID, reportedID, category, reason string) (*model.UserReport, error) {
	rep := &model.UserReport{}
	err := r.pg.Pool.QueryRow(ctx, `
		INSERT INTO user_reports (reporter_id, reported_id, category, reason)
		VALUES ($1, $2, $3, $4)
		RETURNING id, reporter_id, reported_id, category, reason, created_at, resolved_at`,
		reporterID, reportedID, category, reason,
	).Scan(&rep.ID, &rep.ReporterID, &rep.ReportedID, &rep.Category, &rep.Reason, &rep.CreatedAt, &rep.ResolvedAt)
	if err != nil {
		return nil, fmt.Errorf("create report: %w", err)
	}
	return rep, nil
}

// CreatePostReport inserts a post-report row.
func (r *ReportRepo) CreatePostReport(ctx context.Context, reporterID, postID, category, reason string) (*model.PostReport, error) {
	rep := &model.PostReport{}
	err := r.pg.Pool.QueryRow(ctx, `
		INSERT INTO post_reports (reporter_id, post_id, category, reason)
		VALUES ($1, $2, $3, $4)
		RETURNING id, reporter_id, post_id, category, reason, created_at, resolved_at`,
		reporterID, postID, category, reason,
	).Scan(&rep.ID, &rep.ReporterID, &rep.PostID, &rep.Category, &rep.Reason, &rep.CreatedAt, &rep.ResolvedAt)
	if err != nil {
		return nil, fmt.Errorf("create post report: %w", err)
	}
	return rep, nil
}

// ---------------------------------------------------------------------------
// NotificationRepo
// ---------------------------------------------------------------------------

// NotificationRepo persists notification rows. Reads (list / unread
// count / mark-read) will be added when the in-app notification center
// ships; for now the table is write-only, feeding the email fan-out and
// standing ready for websocket/push.
type NotificationRepo struct{ pg *Postgres }

func NewNotificationRepo(pg *Postgres) *NotificationRepo { return &NotificationRepo{pg: pg} }

// Create inserts a notification for recipient userID, triggered by
// actorID (nil for system notifications), of the given kind.
func (r *NotificationRepo) Create(ctx context.Context, userID string, actorID *string, kind string) (*model.Notification, error) {
	n := &model.Notification{}
	err := r.pg.Pool.QueryRow(ctx, `
		INSERT INTO notifications (user_id, actor_id, kind)
		VALUES ($1, $2, $3)
		RETURNING id, user_id, actor_id, kind, created_at, read_at`,
		userID, actorID, kind,
	).Scan(&n.ID, &n.UserID, &n.ActorID, &n.Kind, &n.CreatedAt, &n.ReadAt)
	if err != nil {
		return nil, fmt.Errorf("create notification: %w", err)
	}
	return n, nil
}

// ListByUser returns a recipient's notifications, newest first, with the
// actor's display fields joined in for rendering (nil for system
// notifications or since-deleted actors).
func (r *NotificationRepo) ListByUser(ctx context.Context, userID string, limit, offset int) ([]model.Notification, error) {
	rows, err := r.pg.Pool.Query(ctx, `
		SELECT n.id, n.user_id, n.actor_id, n.kind, n.created_at, n.read_at,
		       u.name, u.handle, u.avatar_url
		FROM notifications n
		LEFT JOIN users u ON u.id = n.actor_id
		WHERE n.user_id = $1
		ORDER BY n.created_at DESC
		LIMIT $2 OFFSET $3`, userID, limit, offset,
	)
	if err != nil {
		return nil, fmt.Errorf("list notifications: %w", err)
	}
	defer rows.Close()
	out := []model.Notification{}
	for rows.Next() {
		var n model.Notification
		if err := rows.Scan(&n.ID, &n.UserID, &n.ActorID, &n.Kind, &n.CreatedAt, &n.ReadAt,
			&n.ActorName, &n.ActorHandle, &n.ActorAvatar); err != nil {
			return nil, fmt.Errorf("scan notification: %w", err)
		}
		out = append(out, n)
	}
	return out, rows.Err()
}

// CountUnread returns how many of a recipient's notifications are unread.
func (r *NotificationRepo) CountUnread(ctx context.Context, userID string) (int, error) {
	var n int
	err := r.pg.Pool.QueryRow(ctx,
		`SELECT count(*) FROM notifications WHERE user_id = $1 AND read_at IS NULL`, userID,
	).Scan(&n)
	if err != nil {
		return 0, fmt.Errorf("count unread notifications: %w", err)
	}
	return n, nil
}

// MarkAllRead stamps read_at on every still-unread notification for the
// user. Idempotent.
func (r *NotificationRepo) MarkAllRead(ctx context.Context, userID string) error {
	_, err := r.pg.Pool.Exec(ctx,
		`UPDATE notifications SET read_at = now() WHERE user_id = $1 AND read_at IS NULL`, userID,
	)
	if err != nil {
		return fmt.Errorf("mark notifications read: %w", err)
	}
	return nil
}