package app

import (
	"context"
	"fmt"

	"gitea.dwysokinski.me/twhelp/core/internal/domain"
)

type DataSyncService struct {
	versionSvc     *VersionService
	serverSvc      *ServerService
	serverPub      ServerPublisher
	ennoblementPub EnnoblementPublisher
}

func NewDataSyncService(
	versionSvc *VersionService,
	serverSvc *ServerService,
	serverPub ServerPublisher,
	ennoblementPub EnnoblementPublisher,
) *DataSyncService {
	return &DataSyncService{
		versionSvc:     versionSvc,
		serverSvc:      serverSvc,
		serverPub:      serverPub,
		ennoblementPub: ennoblementPub,
	}
}

func (svc *DataSyncService) Sync(ctx context.Context) error {
	listVersionsRes, err := svc.versionSvc.List(ctx, domain.NewListVersionsParams())
	if err != nil {
		return err
	}
	versions := listVersionsRes.Versions()

	payloads := make([]domain.SyncServersCmdPayload, 0, len(versions))

	for _, v := range versions {
		p, payloadErr := domain.NewSyncServersCmdPayload(v.Code(), v.URL())
		if payloadErr != nil {
			return fmt.Errorf("%s: couldn't construct domain.SyncServersCmdPayload: %w", v.Code(), payloadErr)
		}

		payloads = append(payloads, p)
	}

	return svc.serverPub.CmdSync(ctx, payloads...)
}

func (svc *DataSyncService) SyncEnnoblements(ctx context.Context) error {
	params := domain.NewListServersParams()
	if err := params.SetOpen(domain.NullBool{
		V:     true,
		Valid: true,
	}); err != nil {
		return err
	}
	if err := params.SetSpecial(domain.NullBool{
		V:     false,
		Valid: true,
	}); err != nil {
		return err
	}

	servers, err := svc.serverSvc.ListAll(ctx, params)
	if err != nil {
		return err
	}

	payloads := make([]domain.SyncEnnoblementsCmdPayload, 0, len(servers))

	for _, s := range servers {
		p, payloadErr := domain.NewSyncEnnoblementsCmdPayload(s.Key(), s.URL(), s.VersionCode())
		if payloadErr != nil {
			return fmt.Errorf("%s: couldn't construct domain.SyncEnnoblementsCmdPayload: %w", s.Key(), payloadErr)
		}

		payloads = append(payloads, p)
	}

	return svc.ennoblementPub.CmdSync(ctx, payloads...)
}