// Package remote implements ports.TargetResolver over internal/remote.
// The resolver logic (address preference, guest wrapping, hosting-compute
// walks) is unchanged; this adapter maps its results onto the port types.
// When the postgres repositories land (Phase 3+), the underlying functions
// move into this package on top of ports.EntityRepository.
package remote

import (
	"context"

	"github.com/google/uuid"

	postgres "github.com/dtoro/oikos/internal/adapters/postgres"
	"github.com/dtoro/oikos/internal/core/domain"
	"github.com/dtoro/oikos/internal/core/ports"
	intremote "github.com/dtoro/oikos/internal/remote"
)

// Resolver resolves execution targets from the entity graph.
type Resolver struct {
	pool *postgres.Pool
}

var _ ports.TargetResolver = (*Resolver)(nil)

// NewResolver builds a resolver over the postgres pool.
func NewResolver(pool *postgres.Pool) *Resolver { return &Resolver{pool: pool} }

func toPort(t intremote.ExecTarget) ports.Target {
	return ports.Target{Host: t.Host, User: t.User, Wrap: t.Wrap}
}

// ResolveExecTarget resolves a slug to its execution endpoint.
func (r *Resolver) ResolveExecTarget(ctx context.Context, targetSlug string) (ports.Target, error) {
	t, err := intremote.ResolveExecTarget(ctx, r.pool, targetSlug, intremote.DefaultUser)
	if err != nil {
		return ports.Target{}, err
	}
	return toPort(t), nil
}

// ResolveForCheck resolves a check's entity (by ID and type) to its endpoint.
func (r *Resolver) ResolveForCheck(ctx context.Context, targetID domain.UUID, targetType string) (ports.Target, error) {
	id, err := uuid.Parse(string(targetID))
	if err != nil {
		return ports.Target{}, err
	}
	t, err := intremote.ResolveExecTargetForCheck(ctx, r.pool, id, targetType, intremote.DefaultUser)
	if err != nil {
		return ports.Target{}, err
	}
	return toPort(t), nil
}

// ResolveHost resolves a host slug to address and SSH user.
func (r *Resolver) ResolveHost(ctx context.Context, hostSlug, fallbackUser string) (string, string, error) {
	return intremote.ResolveHost(ctx, r.pool, hostSlug, fallbackUser)
}

// IsGuest reports whether an entity type is reached via pct/qm exec.
func (r *Resolver) IsGuest(entityType string) bool {
	return intremote.IsGuest(entityType)
}
