package dal

import (
	"bitbucket.org/BlackBroker/heruvym/model"
	"context"
	"github.com/rs/xid"
	"github.com/themakers/hlog"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/mongo/readpref"
	"time"
)

const (
	collMessages = "messages"
	collTickets  = "tickets"
)

type DAL struct {
	logger         hlog.Logger
	colMsg, colTck *mongo.Collection
	client         *mongo.Client
}

type ErrorConnectToDB struct {
	Err      error
	MongoURI string
}

type ErrorPingDB struct {
	Err      error
	MongoURI string
}

type InfoPing struct {
	MongoURI    string
	Nanoseconds int64
}

func New(
	ctx context.Context,
	mongoURI, database string,
	log hlog.Logger,
) (*DAL, error) {
	client, err := mongo.Connect(ctx, options.Client().ApplyURI(mongoURI))
	if err != nil {
		log.Emit(ErrorConnectToDB{
			Err:      err,
			MongoURI: mongoURI,
		})
		return nil, err
	}

	before := time.Now().Unix()

	if err := client.Ping(ctx, readpref.PrimaryPreferred()); err != nil {
		log.Emit(ErrorPingDB{
			Err:      err,
			MongoURI: mongoURI,
		})

		return nil, err
	}

	log.Emit(InfoPing{
		MongoURI:    mongoURI,
		Nanoseconds: time.Now().Unix() - before,
	})

	return &DAL{
		client: client,
		colMsg: client.Database(database).Collection(collMessages),
		colTck: client.Database(database).Collection(collTickets),
		logger: log.Module("DAL"),
	}, nil
}

type ErrorInsert struct {
	Err               error
	UserID, SessionID string
}

func (d *DAL) PutMessage(
	ctx context.Context,
	message, userID, sessionID, ticketID string,
	files []string,
) error {

	if _, err := d.colMsg.InsertOne(ctx, &model.Message{
		ID:        xid.New().String(),
		UserID:    userID,
		SessionID: sessionID,
		TicketID:  ticketID,
		Message:   message,
		Files:     files,
		CreatedAt: time.Now(),
	}); err != nil {
		d.logger.Emit(ErrorInsert{
			Err:       err,
			UserID:    userID,
			SessionID: sessionID,
		})

		return err
	}

	return nil
}

func (d *DAL) CreateTicket(
	ctx context.Context,
	userID,
	sessionID,
	title string,
) (string, error) {

	tiketID := xid.New().String()

	if _, err := d.colTck.InsertOne(ctx, &model.Ticket{
		ID:        tiketID,
		UserID:    userID,
		SessionID: sessionID,
		Title:     title,
		CreatedAt: time.Now(),
	}); err != nil {
		d.logger.Emit(ErrorInsert{
			Err:       err,
			UserID:    userID,
			SessionID: sessionID,
		})

		return "", err
	}

	return tiketID, nil
}