package data

import (
	"context"
	"time"

	"bitbucket.org/jumotechnologies/apivideoanuncios/pkg/ad"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
)

// AdStorage storage to the ad model.
type AdStorage struct {
	c       *mongo.Collection
	storage *Storage
}

// setContext initialize the context to AdStorage.
func (s *AdStorage) setContext() {
	s.storage = New()
	s.c = s.storage.DBCollection(AdCollection)
}

// Create create a new ad.
func (s AdStorage) Create(a *ad.Ad) error {
	s.setContext()
	ctx, cancel := context.WithTimeout(s.storage.Context, 10*time.Second)
	defer cancel()

	a.CreatedAt = time.Now()
	a.UpdatedAt = time.Now()
	a.ID = primitive.NewObjectID()

	_, err := s.c.InsertOne(ctx, a)
	if err != nil {
		return ErrCouldNotInsert
	}

	return nil
}

// Update update ad by ID.
func (s AdStorage) Update(id string, a bson.M) error {
	s.setContext()
	ctx, cancel := context.WithTimeout(s.storage.Context, 10*time.Second)
	defer cancel()

	objectID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		return ErrCouldNotParseID
	}

	delete(a, "userId")
	delete(a, "createdAt")
	delete(a, "id")

	a["updatedAt"] = time.Now()

	r := s.c.FindOneAndUpdate(ctx, bson.M{"_id": objectID}, bson.M{
		"$set": a,
	})

	if r.Err() != nil {
		return ErrCouldNotUpdate
	}

	return nil
}

// Delete remove a ad by ID.
func (s AdStorage) Delete(id string) error {
	s.setContext()
	ctx, cancel := context.WithTimeout(s.storage.Context, 10*time.Second)
	defer cancel()

	objectID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		return ErrCouldNotParseID
	}

	_, err = s.c.DeleteOne(ctx, bson.M{"_id": objectID})
	if err != nil {
		return ErrCouldNotDelete
	}

	return nil
}

// GetAll returns all stored ads.
func (s AdStorage) GetAll() (ad.Ads, error) {
	s.setContext()
	ctx, cancel := context.WithTimeout(s.storage.Context, 10*time.Second)
	defer cancel()

	ads := ad.Ads{}
	cursor, err := s.c.Find(ctx, bson.M{})
	if err != nil {
		return ad.Ads{}, ErrCouldNotFound
	}

	defer cursor.Close(ctx)

	for cursor.Next(ctx) {
		a := &ad.Ad{}
		cursor.Decode(a)
		ads = append(ads, *a)
	}

	return ads, nil
}

// GetByID returns a ad by ID.
func (s AdStorage) GetByID(id string) (ad.Ad, error) {
	s.setContext()
	ctx, cancel := context.WithTimeout(s.storage.Context, 10*time.Second)
	defer cancel()

	objectID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		return ad.Ad{}, ErrCouldNotParseID
	}

	a := ad.Ad{}
	err = s.c.FindOne(ctx, bson.M{"_id": objectID}).Decode(&a)
	if err != nil {
		return ad.Ad{}, ErrCouldNotFound
	}

	return a, nil
}

// GetByUserID returns a ad by UserID.
func (s AdStorage) GetByUserID(uid string) (ad.Ads, error) {
	s.setContext()
	ctx, cancel := context.WithTimeout(s.storage.Context, 10*time.Second)
	defer cancel()

	ads := ad.Ads{}
	cursor, err := s.c.Find(ctx, bson.M{"userId": uid})
	if err != nil {
		return ad.Ads{}, ErrCouldNotFound
	}

	defer cursor.Close(ctx)

	for cursor.Next(ctx) {
		a := &ad.Ad{}
		cursor.Decode(a)
		ads = append(ads, *a)
	}

	return ads, nil
}

// GetByDistance returns stored users by distance.
func (s AdStorage) GetByDistance(lat, long float64, distance int) (ad.Ads, error) {
	s.setContext()
	ctx, cancel := context.WithTimeout(s.storage.Context, 10*time.Second)
	defer cancel()
	var us UserStorage
	users, err := us.GetByDistance(lat, long, distance)
	if err != nil {
		return []ad.Ad{}, ErrCouldNotFound
	}

	uids := bson.A{}
	for _, user := range users {
		uids = append(uids, user.UID)
	}

	ads := ad.Ads{}
	cursor, err := s.c.Find(ctx, bson.M{"userId": bson.M{"$in": uids}})
	if err != nil {
		return ad.Ads{}, ErrCouldNotFound
	}

	defer cursor.Close(ctx)

	for cursor.Next(ctx) {
		a := &ad.Ad{}
		err := cursor.Decode(a)
		if err != nil {
			continue
		}
		ads = append(ads, *a)
	}

	return ads, nil

}

// SearchByText returns all stored ads by text match.
func (s AdStorage) SearchByText(text string) ([]ad.Ad, error) {
	s.setContext()
	ctx, cancel := context.WithTimeout(s.storage.Context, 10*time.Second)
	defer cancel()

	ads := []ad.Ad{}

	cursor, err := s.c.Find(ctx, bson.M{
		"$text": bson.M{"$search": text},
	})
	if err != nil {
		return []ad.Ad{}, ErrCouldNotFound
	}

	defer cursor.Close(ctx)

	a := ad.Ad{}
	for cursor.Next(ctx) {
		cursor.Decode(&a)
		ads = append(ads, a)
	}

	return ads, nil
}

// WithPagination returns all ads with a pagination limit.
func (s AdStorage) WithPagination(ads []ad.Ad, page, limit int) ([]ad.Ad, int, error) {
	total := len(ads)
	if limit > total {
		limit = total
	}
	start := (page - 1) * limit

	ads = ads[start:limit]

	return ads, total, nil
}