package merch

import (
	"context"
	"merch-api/internal/user"
	"merch-api/pkg/utils"

	"github.com/google/uuid"
)

type service struct {
	repo         Repository
	utils        utils.Utils
	userProvider user.Provider
}

func newService(repo Repository, u utils.Utils, up user.Provider) *service {
	return &service{
		repo:         repo,
		utils:        u,
		userProvider: up,
	}
}

//origins

func (s *service) createOrigin(ctx context.Context, o *newOriginDTO) error {
	newOrigin := &Origin{
		CreatedAt: s.utils.TimeNowUTC(),
		DeletedAt: s.utils.DeletedNullTime(),
		Name:      o.Name,
	}

	logDebugService("create origin success")
	return s.repo.createOrigin(ctx, newOrigin)
}

func (s *service) getOrigins(ctx context.Context) (*originsDTO, error) {
	data, err := s.repo.getOrigins(ctx)
	if err != nil {
		logErrService(err)
		return nil, err
	}

	var origins []originItem
	for _, item := range data {
		origins = append(origins, originItem{
			Id:   item.Id,
			Name: item.Name,
		})
	}

	response := &originsDTO{
		Origins: origins,
	}

	logDebugService("get origins success")
	return response, nil
}

func (s *service) deleteOrigin(ctx context.Context, origin *deleteOriginDTO) error {
	logDebugService("delete origin success")
	return s.repo.deleteOriginByName(ctx, origin.Name, s.utils.NullTimeNowUTC())
}

// merch

func (s *service) createMerch(ctx context.Context, userId int64, payload *newMerchDTO) error {
	now := s.utils.TimeNowUTC()
	nullNow := s.utils.NullTimeFromNow(now)
	empty := s.utils.DeletedNullTime()

	merchUuid, err := uuid.NewV7()
	if err != nil {
		logErrService(err)
		return err
	}

	newMerch := &Merch{
		CreatedAt: now,
		UpdatedAt: nullNow,
		DeletedAt: empty,
		MerchUuid: merchUuid.String(),
		UserId:    userId,
		Name:      payload.Name,
	}

	var merchExtra []ExtraData
	if payload.Links != nil {

		originsMap, _, err := s.getOriginsMaps(ctx)
		if err != nil {
			logErrService(err)
			return err
		}

		for _, item := range payload.Links {
			merchExtra = append(merchExtra, ExtraData{
				CreatedAt: now,
				UpdatedAt: nullNow,
				DeletedAt: empty,
				MerchId:   0,
				OriginId:  originsMap[item.Origin],
				URL:       item.Link,
			})
		}
	}

	return s.repo.createMerch(ctx, newMerch, merchExtra)
}

func (s *service) getOriginsMaps(ctx context.Context) (map[string]int64, map[int64]string, error) {
	origins, err := s.repo.getOrigins(ctx)
	if err != nil {
		logErrService(err)
		return nil, nil, err
	}

	namesMap := make(map[string]int64, len(origins))
	idsMap := make(map[int64]string, len(origins))

	for _, origin := range origins {
		namesMap[origin.Name] = origin.Id
		idsMap[origin.Id] = origin.Name
	}

	return namesMap, idsMap, nil
}

func (s *service) getMany(ctx context.Context, userId int64) ([]merchDTO, error) {
	return s.repo.getMany(ctx, userId)
}

func (s *service) updateMerch(ctx context.Context, userId int64, payload *updateMerchDTO) (*merchDTO, error) {
	return s.repo.updateMerch(ctx, userId, payload)
}

func (s *service) updateExtraData(ctx context.Context, userId int64, payload *extraDataDTO) (*extraDataDTO, error) {
	merchId, err := s.repo.getMerchIdByUuid(ctx, userId, payload.MerchUuid)
	if err != nil {
		logErrService(err)
		return nil, err
	}

	origins, ids, err := s.getOriginsMaps(ctx)
	if err != nil {
		logErrService(err)
		return nil, err
	}

	var insertData []ExtraData
	for _, item := range payload.Links {
		if _, ok := origins[item.Origin]; !ok {
			continue
		}

		now := s.utils.TimeNowUTC()

		insertData = append(insertData, ExtraData{
			CreatedAt: now,
			UpdatedAt: s.utils.NullTimeFromNow(now),
			OriginId:  origins[item.Origin],
			URL:       item.Link,
		})
	}

	result, err := s.repo.updateExtraData(ctx, merchId, insertData)
	if err != nil {
		logErrService(err)
		return nil, err
	}

	if result == nil || len(result) == 0 {
		return nil, nil
	}

	var ol []originLink
	for _, item := range result {
		ol = append(ol, originLink{
			Origin: ids[item.OriginId],
			Link:   item.URL,
		})
	}

	return &extraDataDTO{
		MerchUuid: payload.MerchUuid,
		Links:     ol,
	}, nil
}

func (s *service) deleteOneMerchRecord(ctx context.Context, userId int64, merchUuid string) error {
	return s.repo.deleteOneMerchRecord(ctx, userId, merchUuid, s.utils.TimeNowUTC())
}