package supervisor

import (
	"context"
	"strings"
	"time"

	"github.com/example/remote-access-platform/agents/rap-node-agent/internal/client"
)

type Supervisor interface {
	Apply(ctx context.Context, desired []client.DesiredWorkload) ([]client.WorkloadStatusRequest, error)
}

type StubSupervisor struct {
	Version                    string
	RemoteWorkspaceRealAdapter RemoteWorkspaceRealAdapterConfig
}

type RemoteWorkspaceRealAdapterConfig struct {
	EnabledRequested bool
	Command          string
	ArgsJSON         string
	WorkDir          string
}

func (s StubSupervisor) Apply(_ context.Context, desired []client.DesiredWorkload) ([]client.WorkloadStatusRequest, error) {
	statuses := make([]client.WorkloadStatusRequest, 0, len(desired))
	for _, workload := range desired {
		statuses = append(statuses, s.applyOne(workload))
	}
	return statuses, nil
}

func (s StubSupervisor) applyOne(workload client.DesiredWorkload) client.WorkloadStatusRequest {
	serviceType := strings.TrimSpace(workload.ServiceType)
	desiredState := strings.TrimSpace(strings.ToLower(workload.DesiredState))
	if desiredState == "" {
		desiredState = "disabled"
	}
	runtimeMode := strings.TrimSpace(strings.ToLower(workload.RuntimeMode))
	if runtimeMode == "" {
		runtimeMode = "native"
	}
	version := strings.TrimSpace(workload.Version)
	if version == "" {
		version = s.Version
	}
	payload := map[string]any{
		"schema_version": "rap.node_agent.workload_supervision.v1",
		"supervisor":     "node-agent-local",
		"desired_state":  desiredState,
		"service_type":   serviceType,
		"runtime_mode":   runtimeMode,
		"observed_at":    time.Now().UTC().Format(time.RFC3339Nano),
	}
	if desiredState != "enabled" {
		payload["reason"] = "desired_state_not_enabled"
		return client.WorkloadStatusRequest{
			ReportedState: "stopped",
			RuntimeMode:   runtimeMode,
			Version:       version,
			StatusPayload: payload,
		}
	}
	if serviceType == "core-mesh" || serviceType == "mesh-listener" {
		payload["reason"] = "builtin_node_agent_service_ready"
		payload["execution_mode"] = "builtin"
		payload["traffic"] = serviceTrafficMode(serviceType)
		return client.WorkloadStatusRequest{
			ReportedState: "running",
			RuntimeMode:   runtimeMode,
			Version:       version,
			StatusPayload: payload,
		}
	}
	if serviceType == "synthetic.echo" && runtimeMode == "native" {
		payload["reason"] = "internal_synthetic_echo_ready"
		payload["execution_mode"] = "builtin"
		payload["traffic"] = "test_service_only"
		return client.WorkloadStatusRequest{
			ReportedState: "running",
			RuntimeMode:   runtimeMode,
			Version:       version,
			StatusPayload: payload,
		}
	}
	if serviceType == "rdp-worker" && runtimeMode == "native" && boolConfig(workload.Config, "adapter_contract_probe") {
		payload["reason"] = "remote_workspace_adapter_contract_probe_ready"
		payload["execution_mode"] = "contract_probe"
		payload["service_class"] = "remote_workspace"
		payload["fabric_service_channel_required"] = true
		payload["backend_relay_steady_state"] = false
		payload["channels"] = remoteWorkspaceAdapterChannels()
		payload["frame_batch_contract"] = remoteWorkspaceFrameBatchContract()
		payload["real_adapter_supervision"] = remoteWorkspaceRealAdapterSupervisionContract(s.RemoteWorkspaceRealAdapter)
		payload["traffic"] = "none"
		return client.WorkloadStatusRequest{
			ReportedState: "running",
			RuntimeMode:   runtimeMode,
			Version:       version,
			StatusPayload: payload,
		}
	}
	if serviceType == "rdp-worker" && runtimeMode == "native" && boolConfig(workload.Config, "real_adapter_supervision") {
		payload["reason"] = "remote_workspace_real_adapter_supervision_disabled"
		payload["execution_mode"] = "real_adapter_supervision_disabled"
		payload["service_class"] = "remote_workspace"
		payload["traffic"] = "blocked"
		payload["payload_traffic"] = "none"
		payload["real_adapter_supervision"] = remoteWorkspaceRealAdapterSupervisionContract(s.RemoteWorkspaceRealAdapter)
		return client.WorkloadStatusRequest{
			ReportedState: "degraded",
			RuntimeMode:   runtimeMode,
			Version:       version,
			StatusPayload: payload,
		}
	}
	payload["reason"] = "service_runtime_not_implemented"
	payload["traffic"] = "blocked"
	return client.WorkloadStatusRequest{
		ReportedState: "degraded",
		RuntimeMode:   runtimeMode,
		Version:       version,
		StatusPayload: payload,
	}
}

func boolConfig(values map[string]any, key string) bool {
	if values == nil {
		return false
	}
	value, ok := values[key]
	if !ok {
		return false
	}
	switch typed := value.(type) {
	case bool:
		return typed
	case string:
		return strings.EqualFold(strings.TrimSpace(typed), "true")
	default:
		return false
	}
}

func remoteWorkspaceAdapterChannels() []map[string]any {
	return []map[string]any{
		{"name": "input", "direction": "client_to_adapter", "reliability": "reliable_ordered", "priority": "critical", "droppable": true, "may_block_input": false},
		{"name": "control", "direction": "bidirectional", "reliability": "reliable_ordered", "priority": "high", "droppable": false, "may_block_input": false},
		{"name": "display", "direction": "adapter_to_client", "reliability": "droppable_latest", "priority": "high", "droppable": true, "may_block_input": false},
		{"name": "cursor", "direction": "adapter_to_client", "reliability": "droppable_latest", "priority": "high", "droppable": true, "may_block_input": false},
		{"name": "clipboard", "direction": "bidirectional", "reliability": "reliable_ordered", "priority": "medium", "droppable": false, "may_block_input": false},
		{"name": "file_transfer", "direction": "bidirectional", "reliability": "reliable_chunked", "priority": "medium", "droppable": false, "may_block_input": false},
		{"name": "audio", "direction": "adapter_to_client", "reliability": "adaptive_droppable", "priority": "medium", "droppable": true, "may_block_input": false},
		{"name": "device", "direction": "bidirectional", "reliability": "reliable_ordered", "priority": "medium", "droppable": false, "may_block_input": false},
		{"name": "telemetry", "direction": "adapter_to_client", "reliability": "sampled_droppable", "priority": "low", "droppable": true, "may_block_input": false},
	}
}

func remoteWorkspaceFrameBatchContract() map[string]any {
	return map[string]any{
		"schema_version":       "rap.remote_workspace_frame_batch.v1",
		"adapter_contract_id":  "rap.rdp_worker.remote_workspace_adapter_contract_probe.v1",
		"probe_only":           true,
		"payload_forwarding":   "not_implemented",
		"service_class":        "remote_workspace",
		"allowed_flow_classes": []string{"control", "interactive", "reliable", "bulk", "droppable"},
		"allowed_payload_encodings": []string{
			"none",
			"base64",
		},
		"max_probe_frames": 32,
		"channels":         remoteWorkspaceAdapterChannels(),
	}
}

func remoteWorkspaceRealAdapterSupervisionContract(configs ...RemoteWorkspaceRealAdapterConfig) map[string]any {
	var config RemoteWorkspaceRealAdapterConfig
	if len(configs) > 0 {
		config = configs[0]
	}
	return map[string]any{
		"schema_version":                   "rap.remote_workspace_real_adapter_supervision.v1",
		"enabled":                          false,
		"activation_state":                 "disabled_until_real_runtime_stage",
		"execution_mode":                   "real_adapter_supervision_disabled",
		"payload_traffic":                  "none",
		"process_model":                    "external_rdp_worker_process",
		"config_projection":                remoteWorkspaceRealAdapterConfigProjection(config),
		"activation_decision":              remoteWorkspaceRealAdapterActivationDecision(config),
		"process_supervisor_preconditions": remoteWorkspaceRealAdapterProcessSupervisorPreconditions(config),
		"process_health_probe":             remoteWorkspaceRealAdapterProcessHealthProbe(),
		"features": map[string]any{
			"config_projection":                 true,
			"activation_decision":               true,
			"missing_gates":                     true,
			"process_health_probe":              true,
			"process_health_probe_disabled":     true,
			"process_supervisor_preconditions":  true,
			"process_supervisor_start_disabled": true,
			"raw_values_redacted":               true,
		},
		"config_env": []string{
			"RAP_REMOTE_WORKSPACE_REAL_ADAPTER_ENABLED",
			"RAP_REMOTE_WORKSPACE_REAL_ADAPTER_COMMAND",
			"RAP_REMOTE_WORKSPACE_REAL_ADAPTER_ARGS_JSON",
			"RAP_REMOTE_WORKSPACE_REAL_ADAPTER_WORKDIR",
		},
		"status_contract": []string{
			"schema_version",
			"enabled",
			"activation_state",
			"execution_mode",
			"payload_traffic",
			"process_model",
			"config_projection",
			"activation_decision",
			"process_supervisor_preconditions",
			"process_health_probe",
			"features",
			"config_env",
			"status_contract",
		},
		"guardrails": []string{
			"contract_probe_remains_default",
			"no_payload_forwarding_until_real_runtime_stage",
			"backend_relay_not_steady_state",
			"fabric_service_channel_required",
		},
	}
}

func remoteWorkspaceRealAdapterProcessHealthProbe() map[string]any {
	return map[string]any{
		"schema_version":       "rap.remote_workspace_real_adapter_process_health_probe.v1",
		"health_probe_enabled": false,
		"reason":               "disabled_until_real_runtime_stage",
		"payload_traffic":      "none",
		"probe_model":          "external_process_health",
		"required_signals": []string{
			"process_started",
			"process_exit_status",
			"adapter_control_channel_ready",
			"fabric_service_channel_bound",
			"payload_forwarding_contract_ready",
		},
		"missing_signals": []string{
			"process_started",
			"process_exit_status",
			"adapter_control_channel_ready",
			"fabric_service_channel_bound",
			"payload_forwarding_contract_ready",
		},
	}
}

func remoteWorkspaceRealAdapterProcessSupervisorPreconditions(config RemoteWorkspaceRealAdapterConfig) map[string]any {
	return map[string]any{
		"schema_version":         "rap.remote_workspace_real_adapter_process_supervisor_preconditions.v1",
		"process_start_allowed":  false,
		"reason":                 "disabled_until_real_runtime_stage",
		"command_config_present": strings.TrimSpace(config.Command) != "",
		"workdir_config_present": strings.TrimSpace(config.WorkDir) != "",
		"args_config_present":    strings.TrimSpace(config.ArgsJSON) != "",
		"required_checks": []string{
			"real_runtime_stage_enabled",
			"command_config_validated",
			"workdir_config_validated",
			"process_identity_policy_bound",
			"fabric_service_channel_runtime_ready",
			"payload_forwarding_contract_enabled",
			"health_probe_contract_enabled",
		},
		"missing_checks": []string{
			"real_runtime_stage_enabled",
			"command_config_validated",
			"workdir_config_validated",
			"process_identity_policy_bound",
			"fabric_service_channel_runtime_ready",
			"payload_forwarding_contract_enabled",
			"health_probe_contract_enabled",
		},
	}
}

func remoteWorkspaceRealAdapterActivationDecision(config RemoteWorkspaceRealAdapterConfig) map[string]any {
	return map[string]any{
		"schema_version":     "rap.remote_workspace_real_adapter_activation_decision.v1",
		"decision":           "blocked",
		"reason":             "real_runtime_stage_not_enabled",
		"enabled_requested":  config.EnabledRequested,
		"activation_allowed": false,
		"payload_traffic":    "none",
		"required_gates": []string{
			"real_runtime_stage_enabled",
			"fabric_service_channel_runtime_ready",
			"adapter_process_supervisor_enabled",
			"payload_forwarding_contract_enabled",
		},
		"missing_gates": []string{
			"real_runtime_stage_enabled",
			"fabric_service_channel_runtime_ready",
			"adapter_process_supervisor_enabled",
			"payload_forwarding_contract_enabled",
		},
	}
}

func remoteWorkspaceRealAdapterConfigProjection(config RemoteWorkspaceRealAdapterConfig) map[string]any {
	return map[string]any{
		"schema_version":      "rap.remote_workspace_real_adapter_config_projection.v1",
		"enabled_requested":   config.EnabledRequested,
		"activation_allowed":  false,
		"command_present":     strings.TrimSpace(config.Command) != "",
		"args_json_present":   strings.TrimSpace(config.ArgsJSON) != "",
		"args_json_shape":     remoteWorkspaceArgsJSONShape(config.ArgsJSON),
		"workdir_present":     strings.TrimSpace(config.WorkDir) != "",
		"raw_values_redacted": true,
	}
}

func remoteWorkspaceArgsJSONShape(value string) string {
	trimmed := strings.TrimSpace(value)
	if trimmed == "" {
		return "absent"
	}
	switch {
	case strings.HasPrefix(trimmed, "["):
		return "json_array"
	case strings.HasPrefix(trimmed, "{"):
		return "json_object"
	default:
		return "opaque"
	}
}

func serviceTrafficMode(serviceType string) string {
	switch serviceType {
	case "core-mesh":
		return "fabric_control"
	case "mesh-listener":
		return "entry_listener"
	default:
		return "unknown"
	}
}