package signpost

import (
	"context"
	"fmt"
	"strings"

	"git.golem15.com/golem15/summercms/modules/pact"
)

// checkContent validates a type's content descriptor: Model and Describe are
// required when Content is set.
func checkContent(owner string, t pact.MenuItemType) error {
	c := t.Content
	if c == nil {
		return nil
	}
	if strings.TrimSpace(c.Model) == "" {
		return fmt.Errorf("signpost: menu item type %q of plugin %s has a content descriptor without Model", t.Key, owner)
	}
	if c.Describe == nil {
		return fmt.Errorf("signpost: menu item type %q of plugin %s has a content descriptor without Describe", t.Key, owner)
	}
	return nil
}

// ContentTypes returns the types that carry a content descriptor
// (pact.MenuItemType.Content), in registration order. The slice is a copy.
func (r *Registry) ContentTypes() []pact.MenuItemType {
	out := []pact.MenuItemType{}
	if r == nil {
		return out
	}
	for _, t := range r.types {
		if t.Content != nil {
			out = append(out, t)
		}
	}
	return out
}

// ContentTypeForModel returns the content type whose descriptor declares
// model, the morph type record events carry (pact.RecordSaved.Model).
func (r *Registry) ContentTypeForModel(model string) (pact.MenuItemType, bool) {
	if r == nil || model == "" {
		return pact.MenuItemType{}, false
	}
	for _, t := range r.types {
		if t.Content != nil && t.Content.Model == model {
			return t, true
		}
	}
	return pact.MenuItemType{}, false
}

// Describe describes one record of the content type key through its
// descriptor, handing it the layered pattern (Pattern(key, "")). An unknown
// key or a type without a content descriptor is an error; a record the type
// does not know answers nil.
func (r *Registry) Describe(ctx context.Context, key, id, unprefixedLocale string) (*pact.ContentRecord, error) {
	t, err := r.contentType(key)
	if err != nil {
		return nil, err
	}
	if ctx == nil {
		ctx = context.Background()
	}
	return t.Content.Describe(ctx, pact.ContentDescribe{
		ID:               id,
		Pattern:          r.Pattern(key, ""),
		UnprefixedLocale: unprefixedLocale,
	})
}

// contentType is the type key with its content descriptor.
func (r *Registry) contentType(key string) (pact.MenuItemType, error) {
	t, ok := r.Type(key)
	if !ok {
		return pact.MenuItemType{}, fmt.Errorf("signpost: unknown menu item type %q", key)
	}
	if t.Content == nil {
		return pact.MenuItemType{}, fmt.Errorf("signpost: menu item type %q has no content descriptor", key)
	}
	return t, nil
}