package services

/*
  TODO: TO BE DEPRECATED IN 0.25 @RS185722
*/
import (
	"context"
	"database/sql"
	"fmt"

	"github.com/google/uuid"
	"github.com/hashicorp/go-multierror"

	"edge-infra.dev/pkg/edge/api/graph/mapper"
	"edge-infra.dev/pkg/edge/api/graph/model"
	sqlquery "edge-infra.dev/pkg/edge/api/sql"
)

//go:generate mockgen -destination=../mocks/mock_log_classification_service.go -package=mocks edge-infra.dev/pkg/edge/api/services LogClassificationService
type LogClassificationService interface {
	CreateLogClassification(ctx context.Context, bannerEdgeID string, logClassificationEdgeID string, newClusterConfig model.CreateClassificationInput) (*model.LogClassification, error)
	UpdateLogClassification(ctx context.Context, bannerEdgeID string, logClassificationEdgeID string, updatedClusterConfig *model.UpdateClassificationInput) (*model.LogClassification, error)
	GetLogClassification(ctx context.Context, bannerEdgeID string, logClassificationEdgeID string) (*model.LogClassification, error)
	DeleteLogClassification(ctx context.Context, bannerEdgeID string, logClassificationEdgeID string) (bool, error)
	GetLogClassificationsByBanner(ctx context.Context, bannerEdgeID string) ([]*model.LogClassification, error)
}

type logClassificationService struct {
	SQLDB *sql.DB
}

func (l *logClassificationService) GetLogClassification(ctx context.Context, bannerEdgeID string, logClassificationEdgeID string) (*model.LogClassification, error) {
	row := l.SQLDB.QueryRowContext(ctx, sqlquery.GetLogClassification, bannerEdgeID, logClassificationEdgeID)
	logClassification := &model.LogClassification{}
	if err := row.Scan(&logClassification.BannerEdgeID, &logClassification.LogClassificationEdgeID, &logClassification.Description, &logClassification.Pod, &logClassification.Container, &logClassification.Type, &logClassification.Class, &logClassification.Pattern); err != nil {
		return nil, err
	}
	return logClassification, nil
}

func (l *logClassificationService) GetLogClassificationsByBanner(ctx context.Context, bannerEdgeID string) ([]*model.LogClassification, error) {
	row, err := l.SQLDB.QueryContext(ctx, sqlquery.GetLogClassificationsByBanner, bannerEdgeID)
	if err != nil {
		return nil, err
	}

	logClassifications := []*model.LogClassification{}

	for row.Next() {
		logClassification := &model.LogClassification{}
		if err = row.Scan(&logClassification.BannerEdgeID, &logClassification.LogClassificationEdgeID, &logClassification.Description, &logClassification.Pod, &logClassification.Container, &logClassification.Type, &logClassification.Class, &logClassification.Pattern); err != nil {
			return nil, err
		}
		logClassifications = append(logClassifications, logClassification)
	}
	return logClassifications, nil
}

func (l *logClassificationService) DeleteLogClassification(ctx context.Context, bannerEdgeID string, logClassificationEdgeID string) (bool, error) {
	_, err := l.SQLDB.ExecContext(ctx, sqlquery.DeleteLogClassification, bannerEdgeID, logClassificationEdgeID)
	if err != nil {
		return false, fmt.Errorf("Error Deleting Log Classification: %s", err.Error())
	}
	return true, nil
}

func (l *logClassificationService) CreateLogClassification(ctx context.Context, bannerEdgeID string, logClassificationEdgeID string, newClassification model.CreateClassificationInput) (*model.LogClassification, error) {
	logClass, err := mapper.FromLogClassSelection(newClassification.Class)
	if err != nil {
		return nil, err
	}

	/* In reality, all API calls will be blank for this value, but
	   for testing this value need to be parameterized. This will
	   help to avoid the uuid.NewString() mismatch during testing.
	   Also using goMocks.Any() causes issues in the DB saying:
	   could not convert 0 argument gomock.anyMatcher - is anything to driver value: unsupported type gomock.anyMatcher, a struct
	*/
	if logClassificationEdgeID == "" {
		logClassificationEdgeID = uuid.NewString()
	}

	dbClassification := &model.LogClassification{
		BannerEdgeID:            bannerEdgeID,
		LogClassificationEdgeID: logClassificationEdgeID,
		Description:             newClassification.Description,
		Pod:                     newClassification.Pod,
		Container:               newClassification.Container,
		Type:                    newClassification.Type,
		Class:                   logClass,
		Pattern:                 newClassification.Pattern,
	}

	err = l.queryLogClassification(ctx, sqlquery.CreateLogClassification, dbClassification)
	if err != nil {
		return nil, fmt.Errorf("Error Creating Log Classification: %s", err.Error())
	}

	return dbClassification, nil
}

func (l *logClassificationService) UpdateLogClassification(ctx context.Context, bannerEdgeID string, logClassificationEdgeID string, newClassification *model.UpdateClassificationInput) (*model.LogClassification, error) {
	var logClass string
	var err error
	if newClassification.Class != nil {
		logClass, err = mapper.FromLogClassSelection(*newClassification.Class)
		if err != nil {
			return nil, err
		}
	}
	oldClassification, err := l.GetLogClassification(ctx, bannerEdgeID, logClassificationEdgeID)
	if err != nil {
		return nil, err
	}

	updatedClassification := mapper.ToNewClassification(newClassification, oldClassification, logClass)

	err = l.queryLogClassification(ctx, sqlquery.UpdateLogClassification, updatedClassification)
	if err != nil {
		return nil, fmt.Errorf("Error Updating Log Classification: %s", err.Error())
	}
	return updatedClassification, nil
}

// To be used for the INSERT AND UPDATE functions.
func (l logClassificationService) queryLogClassification(ctx context.Context, query string, classificationPayload *model.LogClassification) error {
	transaction, err := l.SQLDB.BeginTx(ctx, nil)
	if err != nil {
		return err
	}

	if _, err := transaction.ExecContext(ctx, query, classificationPayload.BannerEdgeID, classificationPayload.LogClassificationEdgeID, classificationPayload.Description, classificationPayload.Pod, classificationPayload.Container, classificationPayload.Type, classificationPayload.Class, classificationPayload.Pattern); err != nil {
		if rollbackErr := transaction.Rollback(); rollbackErr != nil {
			return multierror.Append(err, rollbackErr)
		}
		return err
	}

	if err = transaction.Commit(); err != nil {
		return err
	}
	return nil
}

// nolint
func NewLogClassificationService(sqlDB *sql.DB) *logClassificationService {
	return &logClassificationService{
		SQLDB: sqlDB,
	}
}