package repository

import (
	"amocrm/internal/models"
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
)

// test +
func (r *Repository) DeletingUserUtm(ctx context.Context, request *model.ListDeleteUTMIDsReq) error {
	var objIDs []primitive.ObjectID

	for _, id := range request.Utms {
		objID, err := primitive.ObjectIDFromHex(id)
		if err != nil {
			return err
		}
		objIDs = append(objIDs, objID)
	}

	filter := bson.M{"_id": bson.M{"$in": objIDs}}

	update := bson.M{"$set": bson.M{"Deleted": true}}

	_, err := r.utms.UpdateMany(ctx, filter, update)
	if err != nil {
		return err
	}

	return nil
}

// test +
func (r *Repository) SavingUserUtm(ctx context.Context, request *models.SaveUserListUTMReq, accountID string, quizID int) (*models.ListSavedIDUTMResp, error) {
	opts := make([]mongo.WriteModel, 0)

	filter := bson.M{
		"ID":     accountID,
		"QuizID": quizID,
	}

	cursor, err := r.utms.Find(ctx, filter)
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

	existingUtms := make(map[string]bool)
	for cursor.Next(ctx) {
		var utm models.UTM
		if err := cursor.Decode(&utm); err != nil {
			fmt.Println(err)
			return nil, err
		}
		existingUtms[utm.Name] = true
	}

	resp := &models.ListSavedIDUTMResp{
		Ids: []string{},
	}

	for _, utm := range request.Utms {
		if !existingUtms[utm.Name] {
			objID := primitive.NewObjectID()
			resp.Ids = append(resp.Ids, objID.Hex())
			opts = append(opts, mongo.NewInsertOneModel().SetDocument(
				bson.M{
					"_id":        objID,
					"Name":       utm.Name,
					"QuizID":     quizID,
					"AccountID":  utm.Accountid,
					"AmoFieldID": utm.Amofieldid,
					"CreatedAt":  utm.Createdat,
					"Deleted":    utm.Deleted,
					"ID":         accountID,
				},
			))
		}
	}

	if len(opts) == 0 {
		return resp, nil
	}

	_, err = r.utms.BulkWrite(ctx, opts)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// test +
func (r *Repository) GettingUserUtm(ctx context.Context, request *models.PaginationReq, accountID string, quizID int) (*models.GetListUserUTMResp, error) {
	offset := (request.Page - 1) * request.Size

	totalUTMS, err := r.utms.CountDocuments(ctx, bson.M{"Deleted": false, "ID": accountID, "QuizID": quizID})
	if err != nil {
		return nil, err
	}

	var utms []models.UTM

	cursor, err := r.utms.Find(ctx, bson.M{"Deleted": false, "ID": accountID, "QuizID": quizID}, options.Find().SetLimit(int64(request.Size)).SetSkip(int64(offset)))
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

	for cursor.Next(ctx) {
		var utm models.UTM
		if err := cursor.Decode(&utm); err != nil {
			return nil, err
		}
		utms = append(utms, utm)
	}
	if err := cursor.Err(); err != nil {
		return nil, err
	}

	utmListResp := &models.GetListUserUTMResp{
		Count: totalUTMS,
		Items: utms,
	}

	return utmListResp, nil
}