package mongos

import (
	"context"
	"errors"
	"github.com/Pena-Co-Ltd/amocrm_templategen_back/dal/model"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.uber.org/zap"
	"time"
)

type TemplateGroup struct {
	coll   *mongo.Collection
	logger *zap.Logger
}

func InitTemplateGroup(db *mongo.Database, logger *zap.Logger) *TemplateGroup {
	return &TemplateGroup{coll: db.Collection("template_group"), logger: logger}
}

func (d *TemplateGroup) Insert(ctx context.Context, record *model.TemplateGroup) (string, error) {
	now := time.Now()
	record.CreatedAt = now
	record.UpdatedAt = now

	if record.UserID == "" {
		err := errors.New("user_id required")
		d.logger.Error("ErrorInsertTemplateGroup", zap.Error(err))
		return "", err
	}

	if record.Name == "" {
		err := errors.New("name required")
		d.logger.Error("ErrorInsertTemplateGroup", zap.Error(err))
		return "", err
	}

	result, err := d.coll.InsertOne(ctx, record)

	if err != nil {
		d.logger.Error("ErrorInsertTemplateGroup", zap.Error(err))
		return "", err
	}

	id := result.InsertedID.(primitive.ObjectID).Hex()

	d.logger.Info("InfoInsertTemplateGroup", zap.String("_id", id))

	return id, nil
}

func (d *TemplateGroup) GetByID(ctx context.Context, id string) (*model.TemplateGroup, error) {
	objID, err := primitive.ObjectIDFromHex(id)

	if err != nil {
		d.logger.Error("ErrorGetTemplateGroup", zap.Error(err))
		return nil, err
	}

	filter := bson.M{"_id": objID}

	var result model.TemplateGroup
	err = d.coll.FindOne(ctx, filter).Decode(&result)

	if err == mongo.ErrNoDocuments {
		return nil, nil
	} else {
		if err != nil {
			d.logger.Error("ErrorGetTemplateGroup", zap.Error(err))
			return nil, err
		}
	}

	d.logger.Info("ErrorGetTemplateGroup", zap.String("id", result.ID))

	return &result, nil
}

func (d *TemplateGroup) GetListByUserID(ctx context.Context, userID string) ([]model.TemplateGroup, error) {
	if userID == "" {
		err := errors.New("user_id required")
		d.logger.Error("ErrorGetListTemplateGroup")
		return nil, err
	}

	filter := bson.M{"user_id": userID}

	var result []model.TemplateGroup

	cur, err := d.coll.Find(ctx, filter)

	if err == mongo.ErrNoDocuments {
		return nil, nil
	} else {
		if err != nil {
			d.logger.Error("ErrorGetTemplateGroup", zap.Error(err))
			return nil, err
		}
	}

	err = cur.All(ctx, &result)

	if err != nil {
		d.logger.Error("ErrorGetListTemplateGroup", zap.Error(err))
		return nil, err
	}

	d.logger.Info("InfoGetListTemplateGroup")

	return result, err
}

func (d *TemplateGroup) Update(ctx context.Context, record *model.TemplateGroup) error {
	objID, err := primitive.ObjectIDFromHex(record.ID)

	if err != nil {
		d.logger.Error("ErrorUpdateTemplateGroup", zap.Error(err))
		return err
	}

	filter := bson.M{"_id": objID}

	if record.UserID != "" {
		filter["user_id"] = record.UserID
	}

	update := bson.M{"updated_at": time.Now()}

	if record.Name != "" {
		update["name"] = record.Name
	}

	_, err = d.coll.UpdateOne(ctx, filter, bson.D{{"$set", update}})

	if err != nil {
		d.logger.Error("ErrorUpdateTemplateGroup")
		return err
	}

	d.logger.Info("InfoUpdateTemplateGroup", zap.String("_id", record.ID))

	return nil
}

func (d *TemplateGroup) Delete(ctx context.Context, id string) error {
	objID, err := primitive.ObjectIDFromHex(id)

	if err != nil {
		d.logger.Error("ErrorDeleteTemplateGroup", zap.Error(err))
		return err
	}

	filter := bson.M{"_id": objID}
	_, err = d.coll.DeleteOne(ctx, filter)

	if err != nil {
		d.logger.Error("ErrorDeleteTemplateGroup", zap.Error(err))
		return err
	}

	return nil
}

func (d *TemplateGroup) DeleteByUserID(ctx context.Context, userID string) error {
	if userID == "" {
		err := errors.New("user_id required")
		d.logger.Error("ErrorDeleteTemplateGroup", zap.Error(err))
		return err
	}

	filter := bson.M{"user_id": userID}

	_, err := d.coll.DeleteMany(ctx, filter)

	if err != nil {
		d.logger.Error("ErrorDeleteTemplateGroup", zap.Error(err))
		return err
	}

	return nil
}