package sandbox

import (
	"context"
	"strings"
)

const StandardTemplateName = "weknora"

// DefaultE2BTemplateTag is the tag E2B resolves when a sandbox is created from a
// bare template name or ID. Builds must carry it to be spawnable at all.
const DefaultE2BTemplateTag = "default"

// TemplateStatusUntagged marks a template whose builds finished but which has no
// build under the tag sandbox creation resolves. It looks identical to "still
// building" in the provider's template list, yet waiting will never help: the
// template needs a new build carrying the default tag.
const TemplateStatusUntagged = "untagged"

// RemoteTemplate is the provider-neutral template projection returned to the
// settings UI. IDs remain opaque; users choose a readable name and status.
type RemoteTemplate struct {
	ID        string `json:"id"`
	Name      string `json:"name"`
	Status    string `json:"status,omitempty"`
	Version   string `json:"version,omitempty"`
	Image     string `json:"image,omitempty"`
	CreatedAt string `json:"created_at,omitempty"`
	UpdatedAt string `json:"updated_at,omitempty"`
	Standard  bool   `json:"standard"`
	// Error carries the provider's own explanation for a failed build. Without
	// it a failed template is a red badge with no way to tell a registry
	// credential problem from an out-of-disk node.
	Error string `json:"error,omitempty"`

	// Cube reports these on GET /templates; other backends leave them empty
	// and the settings list simply omits the corresponding rows.
	InstanceType        string `json:"instance_type,omitempty"`
	NetworkType         string `json:"network_type,omitempty"`
	AllowInternetAccess *bool  `json:"allow_internet_access,omitempty"`
}

// RemoteTemplateCatalog is an optional provider capability used by the
// configuration flow. It stays separate from RemoteSandboxClient because the
// session lifecycle never needs template administration.
type RemoteTemplateCatalog interface {
	ListTemplates(ctx context.Context) ([]RemoteTemplate, error)
	EnsureStandardTemplate(ctx context.Context) (*RemoteTemplate, error)
	// ReplaceStandardTemplate applies the current spec to the cluster's
	// WeKnora template (DNS, image). A READY template cannot pick those up
	// any other way. It must not delete a usable template: callers persist
	// the replacement ID first, then DeleteSupersededStandardTemplates.
	ReplaceStandardTemplate(ctx context.Context) (*RemoteTemplate, error)
	// DeleteSupersededStandardTemplates removes WeKnora templates other than
	// keepID. Call only after keepID is spawnable and has been written onto
	// every config that still pointed at the previous standard template.
	DeleteSupersededStandardTemplates(ctx context.Context, keepID string) error
}

func isStandardTemplate(name string) bool {
	trimmed := strings.Trim(strings.TrimSpace(name), "/")
	if strings.EqualFold(trimmed, StandardTemplateName) {
		return true
	}
	parts := strings.Split(trimmed, "/")
	return len(parts) > 1 && strings.EqualFold(parts[len(parts)-1], StandardTemplateName)
}

// isStandardTemplateImage recognises our template by the image it was built
// from. Names are the primary key, but a provider that drops them — Cube omits
// the field entirely when a template carries no alias — would otherwise make
// every catalog refresh look at a cluster with no standard template and build
// yet another one.
func isStandardTemplateImage(image string) bool {
	candidate := normalizeImageRepository(image)
	return candidate != "" && candidate == normalizeImageRepository(DefaultDockerImage)
}

// normalizeImageRepository reduces an image reference to its repository path so
// that "docker.io/wechatopenai/weknora-sandbox:latest",
// "wechatopenai/weknora-sandbox@sha256:…" and the bare name all compare equal.
func normalizeImageRepository(image string) string {
	ref := strings.TrimSpace(image)
	if ref == "" {
		return ""
	}
	if at := strings.Index(ref, "@"); at >= 0 {
		ref = ref[:at]
	}
	// A colon before the last slash belongs to a registry port, not a tag.
	if colon := strings.LastIndex(ref, ":"); colon > strings.LastIndex(ref, "/") {
		ref = ref[:colon]
	}
	ref = strings.Trim(ref, "/")
	parts := strings.Split(ref, "/")
	// Registry hosts are recognisable by a dot, a port, or being "localhost";
	// anything else at the head is a namespace we must keep.
	if len(parts) > 1 && (strings.ContainsAny(parts[0], ".:") || parts[0] == "localhost") {
		parts = parts[1:]
	}
	if len(parts) > 1 && strings.EqualFold(parts[0], "library") {
		parts = parts[1:]
	}
	return strings.ToLower(strings.Join(parts, "/"))
}

// IsTemplateBuildFailed reports whether a template's build ended in a state no
// amount of waiting will improve. Such a template must be rebuilt rather than
// treated as an existing standard template.
func IsTemplateBuildFailed(status string) bool {
	switch strings.ToLower(strings.TrimSpace(status)) {
	case "failed", "failure", "error", "cancelled", "canceled", TemplateStatusUntagged:
		return true
	default:
		return false
	}
}

// IsTemplateReady reports whether a template can spawn a sandbox. Rebuild
// replacements stay listed alongside the previous READY template until this
// is true, so sessions never lose a spawnable ID mid-build.
func IsTemplateReady(status string) bool {
	switch strings.ToLower(strings.TrimSpace(status)) {
	case "ready", "available", "complete", "completed", "success", "succeeded":
		return true
	default:
		return false
	}
}