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
}

func typedEntry(owner contenttype.ContentType, record entry.Entry, resolver *mediaResolver) (TypedEntry, error) {
	record.Data = entry.Project(owner.Fields, record.Data)
	media, err := resolver.resolve(owner, record)
	if err != nil {
		return TypedEntry{}, err
	}
	return TypedEntry{Entry: record, ContentTypeKey: owner.Key, Media: media}, 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 _, field := range contenttype.MediaFields(owner.Fields) {
		id, set := contenttype.MediaID(data[field.Key])
		if !set {
			continue
		}
		unchanged := stored != nil && storedIDs[field.Key] == id
		if unchanged && !field.Required {
			continue
		}
		exists, err := imageExists(images, id)
		if err != nil {
			return err
		}
		if exists {
			continue
		}
		if unchanged {
			return entry.InvalidField(field.Key, entry.RuleRequired)
		}
		return entry.InvalidField(field.Key, contenttype.RuleType)
	}
	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
}