package useCases

import (
	"RenewCMS/internal/domain/contenttype"
	"RenewCMS/internal/domain/entry"
	"RenewCMS/internal/domain/image"
	"errors"
)

type TypedEntry struct {
	entry.Entry
	ContentTypeKey string
	Media          map[string]EntryMedia
	Relations      map[string]EntryRelations
}

type entryResolvers struct {
	media     *mediaResolver
	relations *relationResolver
}

func newEntryResolvers(images image.Repository, contentTypes contenttype.Repository, entries entry.Repository) *entryResolvers {
	return &entryResolvers{media: newMediaResolver(images), relations: newRelationResolver(contentTypes, entries)}
}

func typedEntry(owner contenttype.ContentType, record entry.Entry, resolvers *entryResolvers) (TypedEntry, error) {
	record.Data = entry.Project(owner.Fields, record.Data)
	media, err := resolvers.media.resolve(owner, record)
	if err != nil {
		return TypedEntry{}, err
	}
	relations, err := resolvers.relations.resolve(owner, record)
	if err != nil {
		return TypedEntry{}, err
	}
	return TypedEntry{Entry: record, ContentTypeKey: owner.Key, Media: media, Relations: relations}, nil
}

func ensureMediaExists(images image.Repository, owner contenttype.ContentType, data map[string]any, stored map[string]any) error {
	storedIDs := entry.MediaIDs(owner.Fields, stored)
	for _, ref := range contenttype.MediaRefs(owner.Fields, data) {
		unchanged := stored != nil && storedIDs[ref.Field.Key] == ref.ID
		if unchanged && !ref.Field.Required {
			continue
		}
		exists, err := imageExists(images, ref.ID)
		if err != nil {
			return err
		}
		if !exists {
			return entry.MissingMedia(ref.Field, unchanged)
		}
	}
	return nil
}

func imageExists(images image.Repository, id uint32) (bool, error) {
	_, err := images.Get(id)
	if errors.Is(err, image.ErrImageNotFound) {
		return false, nil
	}
	return err == nil, err
}

func ensureUnique(entries entry.Repository, owner contenttype.ContentType, data map[string]any, excludeID uint32) error {
	for _, candidate := range entry.UniqueValues(owner.Fields, data) {
		taken, err := entries.FindByFieldValue(owner.ID, candidate.Key, candidate.Value, excludeID)
		if err != nil {
			return err
		}
		if len(taken) > 0 {
			return entry.UniqueViolation(candidate.Key)
		}
	}
	return nil
}