package members

import (
	"context"
	"database/sql"
	"errors"

	"galo/internal/models"
	"galo/internal/sqliteutil"
)

// SQLiteStore is the SQLite implementation of Repository.
type SQLiteStore struct {
	db *sql.DB
}

func NewSQLiteStore(db *sql.DB) *SQLiteStore { return &SQLiteStore{db: db} }

func (s *SQLiteStore) Role(ctx context.Context, albumID, userID string) (string, error) {
	var role string
	err := s.db.QueryRowContext(ctx,
		`SELECT role FROM album_members WHERE album_id = $1 AND user_id = $2`,
		albumID, userID).Scan(&role)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return "", nil
		}
		return "", err
	}
	return role, nil
}

func (s *SQLiteStore) List(ctx context.Context, albumID string) ([]models.AlbumMember, error) {
	rows, err := s.db.QueryContext(ctx,
		`SELECT m.album_id, m.user_id, m.role, m.invited_by, m.joined_at,
		        u.id, u.email, u.name, COALESCE(u.avatar_url, '')
		 FROM album_members m
		 JOIN users u ON u.id = m.user_id
		 WHERE m.album_id = $1
		 ORDER BY m.joined_at`, albumID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	out := []models.AlbumMember{}
	for rows.Next() {
		var m models.AlbumMember
		var invitedBy sql.NullString
		var joinedAt string
		if err := rows.Scan(&m.AlbumID, &m.UserID, &m.Role, &invitedBy, &joinedAt,
			&m.User.ID, &m.User.Email, &m.User.Name, &m.User.AvatarURL); err != nil {
			return nil, err
		}
		if invitedBy.Valid {
			m.InvitedBy = &invitedBy.String
		}
		m.JoinedAt = sqliteutil.ParseTime(joinedAt)
		out = append(out, m)
	}
	return out, rows.Err()
}

// Audience returns the owner id plus every member id for the album. It reads
// both from their own tables (no join with users) because the fan-out only
// needs identifiers.
func (s *SQLiteStore) Audience(ctx context.Context, albumID string) ([]string, error) {
	rows, err := s.db.QueryContext(ctx,
		`SELECT owner_id FROM albums WHERE id = $1
		 UNION
		 SELECT user_id FROM album_members WHERE album_id = $1
		 ORDER BY 1`, albumID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	out := []string{}
	for rows.Next() {
		var id string
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		out = append(out, id)
	}
	return out, rows.Err()
}

func (s *SQLiteStore) Add(ctx context.Context, albumID, userID, role string, invitedBy *string) error {
	_, err := s.db.ExecContext(ctx,
		`INSERT INTO album_members (album_id, user_id, role, invited_by)
		 VALUES ($1, $2, $3, $4)
		 ON CONFLICT (album_id, user_id) DO UPDATE SET role = excluded.role`,
		albumID, userID, role, invitedBy)
	return err
}

func (s *SQLiteStore) UpdateRole(ctx context.Context, albumID, userID, role string) error {
	res, err := s.db.ExecContext(ctx,
		`UPDATE album_members SET role = $3 WHERE album_id = $1 AND user_id = $2`,
		albumID, userID, role)
	if err != nil {
		return err
	}
	if n, _ := res.RowsAffected(); n == 0 {
		return ErrNotFound
	}
	return nil
}

func (s *SQLiteStore) Remove(ctx context.Context, albumID, userID string) error {
	res, err := s.db.ExecContext(ctx,
		`DELETE FROM album_members WHERE album_id = $1 AND user_id = $2`, albumID, userID)
	if err != nil {
		return err
	}
	if n, _ := res.RowsAffected(); n == 0 {
		return ErrNotFound
	}
	return nil
}

func (s *SQLiteStore) CreateInvite(ctx context.Context, inv *models.Invite) error {
	var createdAt string
	err := s.db.QueryRowContext(ctx,
		`INSERT INTO invites (id, album_id, token, role, created_by, expires_at, max_uses)
		 VALUES ($1, $2, $3, $4, $5, $6, $7)
		 RETURNING created_at`,
		inv.ID, inv.AlbumID, inv.Token, inv.Role, inv.CreatedBy, sqliteutil.FormatTime(inv.ExpiresAt), inv.MaxUses,
	).Scan(&createdAt)
	if err != nil {
		return err
	}
	inv.CreatedAt = sqliteutil.ParseTime(createdAt)
	return nil
}

func (s *SQLiteStore) GetInviteByToken(ctx context.Context, token string) (*models.Invite, error) {
	var inv models.Invite
	var expiresAt, createdAt string
	err := s.db.QueryRowContext(ctx,
		`SELECT id, album_id, token, role, created_by, expires_at, max_uses, uses, created_at
		 FROM invites WHERE token = $1`, token).
		Scan(&inv.ID, &inv.AlbumID, &inv.Token, &inv.Role, &inv.CreatedBy, &expiresAt, &inv.MaxUses, &inv.Uses, &createdAt)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, ErrNotFound
		}
		return nil, err
	}
	inv.ExpiresAt = sqliteutil.ParseTime(expiresAt)
	inv.CreatedAt = sqliteutil.ParseTime(createdAt)
	return &inv, nil
}

func (s *SQLiteStore) IncrementUses(ctx context.Context, id string) error {
	_, err := s.db.ExecContext(ctx, `UPDATE invites SET uses = uses + 1 WHERE id = $1`, id)
	return err
}