package middleware

import (
	"context"

	"git.perx.ru/perxis/perxis-go/id"
	"git.perx.ru/perxis/perxis-go/pkg/spaces"

	logzap "git.perx.ru/perxis/perxis-go/zap"
	"go.uber.org/zap"
)

type loggingMiddleware struct {
	logger *zap.Logger
	next   spaces.Spaces
}

func LoggingMiddleware(logger *zap.Logger) Middleware {
	return func(next spaces.Spaces) spaces.Spaces {
		return &loggingMiddleware{
			next:   next,
			logger: logger.With(logzap.Component("Spaces")),
		}
	}
}

func (m *loggingMiddleware) AbortTransfer(ctx context.Context, spaceID string) (err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
		logzap.Event(spaces.EventAbortTransfer),
		logzap.Object(id.NewSpaceId(spaceID)),
	)

	err = m.next.AbortTransfer(ctx, spaceID)
	if err != nil {
		logger.Error("Failed to abort transfer", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
		return
	}

	logger.Info("Aborted space transfer", logzap.Channels(logzap.Userlog))

	return err
}

func (m *loggingMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
		logzap.Event(spaces.EventCreate),
	)

	created, err = m.next.Create(ctx, space)
	if err != nil {
		logger.Error("Failed to create", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog), logzap.Object(space))
		return
	}

	logger.Info("Space created", logzap.Channels(logzap.Userlog), logzap.Object(created))

	return created, err
}

func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
		logzap.Event(spaces.EventDelete),
		logzap.Object(id.NewSpaceId(spaceId)),
	)

	err = m.next.Delete(ctx, spaceId)
	if err != nil {
		logger.Error("Failed to delete", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
		return
	}

	logger.Info("Space deleted", logzap.Channels(logzap.Userlog))

	return err
}

func (m *loggingMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
		logzap.Object(id.NewSpaceId(spaceId)),
	)

	space, err = m.next.Get(ctx, spaceId)
	if err != nil {
		logger.Error("Failed to get", zap.Error(err))
		return
	}

	return space, err
}

func (m *loggingMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
	)

	spaces, err = m.next.List(ctx, orgId)
	if err != nil {
		logger.Error("Failed to list", zap.Error(err))
		return
	}

	return spaces, err
}

func (m *loggingMiddleware) ListTransfers(ctx context.Context, orgID string) (spaces []*spaces.Space, err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
	)

	spaces, err = m.next.ListTransfers(ctx, orgID)
	if err != nil {
		logger.Error("Failed to list transfers", zap.Error(err))
		return
	}

	return spaces, err
}

func (m *loggingMiddleware) Move(ctx context.Context, spaceID string, orgID string) (err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
		logzap.Event(spaces.EventMove),
		logzap.Object(id.NewSpaceId(spaceID)),
	)

	err = m.next.Move(ctx, spaceID, orgID)
	if err != nil {
		logger.Error("Failed to move", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
		return
	}

	logger.Info("Space moved", logzap.Channels(logzap.Userlog))

	return err
}

func (m *loggingMiddleware) Transfer(ctx context.Context, spaceID string, transferToOrg string) (err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
		logzap.Event(spaces.EventTransfer),
		logzap.Object(id.NewSpaceId(spaceID)),
	)

	err = m.next.Transfer(ctx, spaceID, transferToOrg)
	if err != nil {
		logger.Error("Failed to transfer", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
		return
	}

	logger.Info("Space transferred", logzap.Channels(logzap.Userlog))

	return err
}

func (m *loggingMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
		logzap.Event(spaces.EventUpdate),
		logzap.Object(space),
	)

	err = m.next.Update(ctx, space)
	if err != nil {
		logger.Error("Failed to update", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
		return
	}

	logger.Info("Space updated", logzap.Channels(logzap.Userlog))

	return err
}

func (m *loggingMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
	logger := m.logger.With(
		logzap.Caller(ctx),
		logzap.Event(spaces.EventUpdateConfig),
		logzap.Object(id.NewSpaceId(spaceId)),
	)

	err = m.next.UpdateConfig(ctx, spaceId, config)
	if err != nil {
		logger.Error("Failed to update config", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
		return
	}

	logger.Info("Updated space config", logzap.Channels(logzap.Userlog))

	return err
}