package auth

import (
	"context"
	"time"

	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

type Repository struct {
	usersCollection         *mongo.Collection
	refreshTokensCollection *mongo.Collection
}

func NewRepository(db *mongo.Database) *Repository {
	return &Repository{
		usersCollection:         db.Collection("users"),
		refreshTokensCollection: db.Collection("refresh_tokens"),
	}
}

func (r *Repository) EnsureIndexes(ctx context.Context) error {
	_, err := r.usersCollection.Indexes().CreateOne(ctx, mongo.IndexModel{
		Keys:    bson.D{{Key: "email", Value: 1}},
		Options: options.Index().SetUnique(true),
	})
	if err != nil {
		return err
	}

	_, err = r.refreshTokensCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: "token_hash", Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys:    bson.D{{Key: "expires_at", Value: 1}},
			Options: options.Index().SetExpireAfterSeconds(0),
		},
	})
	return err
}

func (r *Repository) CreateUser(ctx context.Context, user *User) error {
	user.ID = bson.NewObjectID()
	user.CreatedAt = time.Now().UTC()
	_, err := r.usersCollection.InsertOne(ctx, user)
	return err
}

func (r *Repository) FindByEmail(ctx context.Context, email string) (*User, error) {
	var user User
	err := r.usersCollection.FindOne(ctx, bson.M{"email": email}).Decode(&user)
	if err != nil {
		return nil, err
	}
	return &user, nil
}

func (r *Repository) FindByID(ctx context.Context, id bson.ObjectID) (*User, error) {
	var user User
	err := r.usersCollection.FindOne(ctx, bson.M{"_id": id}).Decode(&user)
	if err != nil {
		return nil, err
	}
	return &user, nil
}

//Refresh

func (r *Repository) CreateRefreshToken(ctx context.Context, doc *RefreshTokenDoc) error {
	doc.ID = bson.NewObjectID()
	doc.CreatedAt = time.Now().UTC()
	_, err := r.refreshTokensCollection.InsertOne(ctx, doc)
	return err
}

func (r *Repository) FindRefreshTokenByHash(ctx context.Context, hash string) (*RefreshTokenDoc, error) {
	var doc RefreshTokenDoc
	err := r.refreshTokensCollection.FindOne(ctx, bson.M{"token_hash": hash}).Decode(&doc)
	if err != nil {
		return nil, err
	}
	return &doc, nil
}

func (r *Repository) DeleteRefreshToken(ctx context.Context, id bson.ObjectID) error {
	_, err := r.refreshTokensCollection.DeleteOne(ctx, bson.M{"_id": id})
	return err
}

func (r *Repository) DeleteRefreshTokenByHash(ctx context.Context, hash string) (bool, error) {
	res, err := r.refreshTokensCollection.DeleteOne(ctx, bson.M{"token_hash": hash})
	if err != nil {
		return false, err
	}
	return res.DeletedCount > 0, nil
}