package repository

import (
	"amocrm/internal/models"
	"amocrm/internal/models/amo"
	"context"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

func (r *Repository) GettingFieldsFromCash(ctx context.Context, req *models.PaginationReq) (*models.UserListFieldsResp, error) {
	offset := (req.Page - 1) * req.Size

	totalFields, err := r.fields.CountDocuments(ctx, bson.M{"deleted": false})
	if err != nil {
		return nil, err
	}

	var fields []models.Field

	cursor, err := r.fields.Find(ctx, bson.M{"deleted": false}, options.Find().SetLimit(int64(req.Size)).SetSkip(int64(offset)))
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

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

	fieldListResp := &models.UserListFieldsResp{
		Count: totalFields,
		Items: fields,
	}

	return fieldListResp, nil
}

func (r *Repository) UpdateListCustom(ctx context.Context) error {
	//TODO:IMPLEMENT ME

	return nil

}

type CheckFieldsDeps struct {
	AccountID  string // id quiz
	ID         int    // id amo
	EntityType models.EntityType
	Fields     []amo.CustomField
}

func (r *Repository) CheckFields(ctx context.Context, deps CheckFieldsDeps) error {
	for _, f := range deps.Fields {
		field := models.Field{
			ID:        deps.AccountID,
			Accountid: deps.ID,
			Amoid:     f.ID,
			Name:      f.Name,
			Type:      f.Type,
			Code:      f.Code,
			Entity:    deps.EntityType,
		}

		existingField, err := r.GetFieldByID(ctx, deps.AccountID, f.ID, deps.EntityType)
		if err != nil {
			return err
		}

		if existingField != nil {
			field.UpdateAt = time.Now().Unix()
			err = r.UpdateField(ctx, &field)
			if err != nil {
				return err
			}
		} else {
			field.Createdat = time.Now().Unix()
			err = r.InsertField(ctx, &field)
			if err != nil {
				return err
			}
		}
	}

	return nil
}

// test +
func (r *Repository) GetFieldByID(ctx context.Context, accountID string, amoid int, entity models.EntityType) (*models.Field, error) {
	var field models.Field
	filter := bson.M{"id": accountID, "amoid": amoid, "entity": entity}
	err := r.fields.FindOne(ctx, filter).Decode(&field)
	if err == mongo.ErrNoDocuments {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return &field, nil
}

// test +
func (r *Repository) UpdateField(ctx context.Context, field *models.Field) error {
	filter := bson.M{"id": field.ID, "amoid": field.Amoid, "entity": field.Entity}
	update := bson.M{"$set": bson.M{
		"accountid": field.Accountid,
		"name":      field.Name,
		"updateAt":  field.UpdateAt,
		"type":      field.Type,
		"entity":    field.Entity,
		"code":      field.Code,
	}}
	_, err := r.fields.UpdateOne(ctx, filter, update)
	return err
}

// test +
func (r *Repository) InsertField(ctx context.Context, field *models.Field) error {
	_, err := r.fields.InsertOne(ctx, field)
	return err
}