package commands

import (
	"context"
	"fmt"

	"github.com/pharos-ai-factory/pharos-platform/services/beto/contexts/project/application/ports"
	"github.com/pharos-ai-factory/pharos-platform/services/beto/contexts/project/domain"
	foundation "github.com/pharos-ai-factory/pharos-platform/services/beto/foundation/application"
)

type ObserveExternalProjectCommand = ports.PreparedObservation

type ObserveExternalProjectCommandHandler struct {
	Admission  ports.ObservationAdmission
	Repository ports.ProjectWriteRepository
}

func (h ObserveExternalProjectCommandHandler) Execute(ctx context.Context, target foundation.CommandContext, command ObserveExternalProjectCommand) (foundation.CommandResult, error) {
	if err := ctx.Err(); err != nil {
		return foundation.CommandResult{}, err
	}
	if err := command.Validate(); err != nil {
		return foundation.CommandResult{}, err
	}
	if target.Target != command.Claim.ProjectID || target.ActorID != "" {
		return foundation.CommandResult{}, fmt.Errorf("source observation target or authority differs from its claim")
	}
	if err := h.Admission.CheckObservation(ctx, command); err != nil {
		return foundation.CommandResult{}, err
	}
	loaded, err := h.Repository.Get(ctx, target.Target)
	if err != nil {
		return foundation.CommandResult{}, err
	}
	var project *domain.Project
	changed := true
	if loaded.Exists {
		project = loaded.State
		if project == nil || loaded.Version == 0 || loaded.Version != command.Claim.ExpectedVersion {
			return foundation.CommandResult{}, fmt.Errorf("project state differs from the acquired revision")
		}
		snapshot := project.Snapshot()
		if snapshot.ProjectID != target.Target || snapshot.Source != command.Claim.Source ||
			snapshot.ScopeRef != command.Claim.ScopeRef || snapshot.ManagementGeneration != command.Claim.ManagementGeneration {
			return foundation.CommandResult{}, fmt.Errorf("project source ownership differs from its acquisition")
		}
		changed, err = project.Observe(command.Acquisition.Name, command.Acquisition.ScopeName, command.Members)
	} else {
		if loaded.Version != 0 || command.Claim.ExpectedVersion != 0 {
			return foundation.CommandResult{}, fmt.Errorf("missing Project has a nonzero acquisition revision")
		}
		project, err = domain.NewProject(command.Snapshot())
	}
	if err != nil {
		return foundation.CommandResult{}, err
	}
	if changed {
		if err := h.Repository.Save(ctx, project); err != nil {
			return foundation.CommandResult{}, err
		}
	}
	evidence, err := command.Evidence(project.Snapshot())
	if err != nil {
		return foundation.CommandResult{}, err
	}
	if err := h.Repository.RecordSourceSuccess(ctx, evidence); err != nil {
		return foundation.CommandResult{}, err
	}
	if changed {
		return foundation.Result("observed"), nil
	}
	return foundation.Result("unchanged"), nil
}