package auth

import (
	"context"
	"database/sql"
	"fmt"
	"time"
)

type Repository struct {
	Db *sql.DB
}

func NewRepository(db *sql.DB) (*Repository, error) {
	return &Repository{Db: db}, nil
}

func (r *Repository) CreateInvite(ctx context.Context, token string, uses int64, expiresAt time.Time) (*Invite, error) {
	query := "INSERT INTO invites(token, uses, expiresat) VALUES(?, ?, ?) RETURNING createdat"

	invite := &Invite{Token: token, Uses: uses, ExpiresAt: expiresAt}
	if err := r.Db.QueryRowContext(ctx, query, token, uses, expiresAt).Scan(&invite.CreatedAt); err != nil {
		return nil, fmt.Errorf("db insert failed: %w", err)
	}

	return invite, nil
}

func (r *Repository) GetInviteByToken(ctx context.Context, token string) (*Invite, error) {
	query := "SELECT uses, expiresat, createdat FROM invites WHERE token = ?"
	invite := &Invite{Token: token}
	if err := r.Db.QueryRowContext(ctx, query, token).Scan(&invite.Uses, &invite.ExpiresAt, &invite.CreatedAt); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	return invite, nil
}

func (r *Repository) GetInvites(ctx context.Context, limit, offset int64) ([]Invite, error) {
	query := "SELECT token, uses, expiresat, createdat FROM invites LIMIT ? OFFSET ?"
	rows, err := r.Db.QueryContext(ctx, query, limit, offset)
	if err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}
	defer rows.Close()

	var invites []Invite
	for rows.Next() {
		var invite Invite

		if err := rows.Scan(&invite.Token, &invite.Uses, &invite.ExpiresAt, &invite.CreatedAt); err != nil {
			return nil, fmt.Errorf("db select failed: %w", err)
		}

		invites = append(invites, invite)
	}

	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	return invites, nil
}

func (r *Repository) GetInvitesCount(ctx context.Context) (int64, error) {
	query := "SELECT COUNT(*) FROM invites"
	var result int64
	if err := r.Db.QueryRowContext(ctx, query).Scan(&result); err != nil {
		return 0, fmt.Errorf("db select failed: %w", err)
	}

	return result, nil
}

func (r *Repository) UpdateInvite(ctx context.Context, invite *Invite) error {
	query := "UPDATE invites SET uses = ?, expiresat = ? WHERE token = ?"

	_, err := r.Db.ExecContext(ctx, query, invite.Uses, invite.ExpiresAt, invite.Token)
	if err != nil {
		return fmt.Errorf("db update failed: %w", err)
	}
	return nil
}

func (r *Repository) DeleteInvite(ctx context.Context, token string) error {
	query := "DELETE FROM invites WHERE token = ?"

	_, err := r.Db.ExecContext(ctx, query, token)
	if err != nil {
		return fmt.Errorf("db delete failed: %w", err)
	}
	return nil
}

func (r *Repository) CreateSession(ctx context.Context, token string, userId int64, device, address string, expiresAt time.Time) (*Session, error) {
	query := "INSERT INTO sessions(token, userid, device, address, expiresat) VALUES(?, ?, ?, ?, ?) RETURNING createdat"

	session := &Session{Token: token, UserId: userId, Device: device, Address: address, ExpiresAt: expiresAt}
	if err := r.Db.QueryRowContext(ctx, query, token, userId, device, address, expiresAt).Scan(&session.CreatedAt); err != nil {
		return nil, fmt.Errorf("db insert failed: %w", err)
	}

	return session, nil
}

func (r *Repository) GetSessionByToken(ctx context.Context, token string) (*Session, error) {
	query := "SELECT userid, device, address, expiresat, createdat FROM sessions WHERE token = ?"
	session := &Session{Token: token}
	if err := r.Db.QueryRowContext(ctx, query, token).Scan(&session.UserId, &session.Device, &session.Address, &session.ExpiresAt, &session.CreatedAt); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	return session, nil
}

func (r *Repository) GetSessionByUserId(ctx context.Context, userId int64, limit, offset int64) ([]Session, error) {
	query := "SELECT token, userid, device, address, expiresat, createdat FROM sessions WHERE userid = ? LIMIT ? OFFSET ?"
	rows, err := r.Db.QueryContext(ctx, query, userId, limit, offset)
	if err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}
	defer rows.Close()

	var sessions []Session
	for rows.Next() {
		var session Session

		if err := rows.Scan(&session.Token, &session.UserId, &session.Device, &session.Address, &session.ExpiresAt, &session.CreatedAt); err != nil {
			return nil, fmt.Errorf("db select failed: %w", err)
		}

		sessions = append(sessions, session)
	}

	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	return sessions, nil
}

func (r *Repository) GetSessionByUserIdCount(ctx context.Context, userId int64) (int64, error) {
	query := "SELECT COUNT(*) FROM sessions WHERE userid = ?"
	var result int64
	if err := r.Db.QueryRowContext(ctx, query, userId).Scan(&result); err != nil {
		return 0, fmt.Errorf("db select failed: %w", err)
	}

	return result, nil
}

func (r *Repository) DeleteSession(ctx context.Context, token string) error {
	query := "DELETE FROM sessions WHERE token = ?"

	_, err := r.Db.ExecContext(ctx, query, token)
	if err != nil {
		return fmt.Errorf("db delete failed: %w", err)
	}
	return nil
}

func (r *Repository) DeleteSessionByTokenAndUserId(ctx context.Context, token string, userId int64) error {
	query := "DELETE FROM sessions WHERE token = ? AND userid = ?"
	_, err := r.Db.ExecContext(ctx, query, token, userId)
	if err != nil {
		return fmt.Errorf("db delete failed: %w", err)
	}
	return nil
}

func (r *Repository) DeleteSessionsByUserId(ctx context.Context, userId int64) error {
	query := "DELETE FROM sessions WHERE userid = ?"

	_, err := r.Db.ExecContext(ctx, query, userId)
	if err != nil {
		return fmt.Errorf("db delete failed: %w", err)
	}
	return nil
}

// DeleteExpiredSessions deletes all sessions whose expiresat < now.
// Returns the number of rows deleted.
func (r *Repository) DeleteExpiredSessions(ctx context.Context) (int64, error) {
	result, err := r.Db.ExecContext(ctx,
		"DELETE FROM sessions WHERE expiresat < datetime('now')",
	)
	if err != nil {
		return 0, fmt.Errorf("delete expired sessions: %w", err)
	}
	return result.RowsAffected()
}