package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"time"

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

type smokeNode struct {
	Local   mesh.PeerIdentity
	Runtime *mesh.SyntheticRuntime
	URL     string
	server  *httptest.Server
}

type smokeReport struct {
	Stage                  string         `json:"stage"`
	ProductionForwarding   bool           `json:"production_forwarding"`
	ScopedConfigLoaded     bool           `json:"scoped_config_loaded"`
	DirectProbeAccepted    bool           `json:"direct_probe_accepted"`
	DirectPath             []string       `json:"direct_path"`
	RelayProbeAccepted     bool           `json:"relay_probe_accepted"`
	RelayPath              []string       `json:"relay_path"`
	TestServiceAccepted    bool           `json:"test_service_accepted"`
	TestServiceEchoPayload string         `json:"test_service_echo_payload"`
	PeerEndpoints          map[string]any `json:"peer_endpoints"`
}

func main() {
	report, err := run(context.Background())
	if err != nil {
		fmt.Fprintf(os.Stderr, "mesh live smoke failed: %v\n", err)
		os.Exit(1)
	}
	payload, err := json.MarshalIndent(report, "", "  ")
	if err != nil {
		fmt.Fprintf(os.Stderr, "marshal report: %v\n", err)
		os.Exit(1)
	}
	fmt.Println(string(payload))
}

func run(ctx context.Context) (smokeReport, error) {
	nodeA := newSmokeNode(mesh.PeerIdentity{ClusterID: "cluster-1", NodeID: "node-a"})
	defer nodeA.Close()
	nodeR := newSmokeNode(mesh.PeerIdentity{ClusterID: "cluster-1", NodeID: "node-r"})
	defer nodeR.Close()
	nodeB := newSmokeNode(mesh.PeerIdentity{ClusterID: "cluster-1", NodeID: "node-b"})
	defer nodeB.Close()

	directRoute := smokeRoute("route-direct", []string{"node-a", "node-b"})
	relayRoute := smokeRoute("route-relay", []string{"node-a", "node-r", "node-b"})
	routes := []mesh.SyntheticRoute{directRoute, relayRoute}
	nodeAConfigPath, err := writeSmokeScopedConfig(nodeA.Local, map[string]string{
		"node-r": nodeR.URL,
		"node-b": nodeB.URL,
	}, routes)
	if err != nil {
		return smokeReport{}, err
	}
	nodeAConfig, err := mesh.LoadScopedSyntheticConfig(nodeAConfigPath, nodeA.Local)
	if err != nil {
		return smokeReport{}, fmt.Errorf("load node-a scoped config: %w", err)
	}

	nodeA.Runtime = smokeRuntime(nodeA.Local, nodeAConfig.Routes, nodeAConfig.PeerEndpoints)
	nodeR.Runtime = smokeRuntime(nodeR.Local, routes, map[string]string{
		"node-b": nodeB.URL,
	})
	nodeB.Runtime = smokeRuntime(nodeB.Local, routes, map[string]string{})

	directAck, err := nodeA.Runtime.SendProbe(ctx, directRoute.RouteID, mesh.SyntheticChannelFabricControl, "smoke-direct")
	if err != nil {
		return smokeReport{}, fmt.Errorf("direct probe: %w", err)
	}
	relayAck, err := nodeA.Runtime.SendProbe(ctx, relayRoute.RouteID, mesh.SyntheticChannelFabricControl, "smoke-relay")
	if err != nil {
		return smokeReport{}, fmt.Errorf("relay probe: %w", err)
	}
	testService, err := nodeA.Runtime.SendTestService(ctx, relayRoute.RouteID, mesh.SyntheticChannelRouteControl, mesh.SyntheticTestServiceRequest{
		RequestID:      "smoke-test-service",
		OrganizationID: mesh.SyntheticDefaultTestOrganizationID,
		ServiceType:    mesh.SyntheticTestServiceType,
		Payload:        "hello-c17e",
		SentAt:         time.Now().UTC(),
	})
	if err != nil {
		return smokeReport{}, fmt.Errorf("test service: %w", err)
	}

	return smokeReport{
		Stage:                  "C17F scoped synthetic config plus live HTTP transport",
		ProductionForwarding:   false,
		ScopedConfigLoaded:     nodeAConfig.ConfigVersion == "smoke-config-v1",
		DirectProbeAccepted:    directAck.MessageType == mesh.SyntheticMessageProbeAck,
		DirectPath:             decodeProbePath(directAck),
		RelayProbeAccepted:     relayAck.MessageType == mesh.SyntheticMessageProbeAck,
		RelayPath:              decodeProbePath(relayAck),
		TestServiceAccepted:    testService.Ack.MessageType == mesh.SyntheticMessageTestServiceAck,
		TestServiceEchoPayload: testService.Response.EchoPayload,
		PeerEndpoints: map[string]any{
			"node-a": nodeA.URL,
			"node-r": nodeR.URL,
			"node-b": nodeB.URL,
		},
	}, nil
}

func writeSmokeScopedConfig(local mesh.PeerIdentity, peers map[string]string, routes []mesh.SyntheticRoute) (string, error) {
	path := filepath.Join(os.TempDir(), "rap-c17e-node-a-scoped-mesh.json")
	payload, err := json.Marshal(mesh.ScopedSyntheticConfig{
		SchemaVersion:        "c17f.synthetic.v1",
		ClusterID:            local.ClusterID,
		LocalNodeID:          local.NodeID,
		ConfigVersion:        "smoke-config-v1",
		PeerDirectoryVersion: "smoke-peers-v1",
		PolicyVersion:        "smoke-policy-v1",
		PeerEndpoints:        peers,
		Routes:               routes,
	})
	if err != nil {
		return "", err
	}
	if err := os.WriteFile(path, payload, 0o600); err != nil {
		return "", err
	}
	return path, nil
}

func newSmokeNode(local mesh.PeerIdentity) *smokeNode {
	node := &smokeNode{Local: local}
	node.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		mesh.Server{Local: node.Local, SyntheticRuntime: node.Runtime}.Handler().ServeHTTP(w, r)
	}))
	node.URL = node.server.URL
	return node
}

func (n *smokeNode) Close() {
	if n.server != nil {
		n.server.Close()
	}
}

func smokeRuntime(local mesh.PeerIdentity, routes []mesh.SyntheticRoute, peers map[string]string) *mesh.SyntheticRuntime {
	return mesh.NewSyntheticRuntime(mesh.SyntheticRuntimeConfig{
		Enabled: true,
		Local:   local,
		Routes:  routes,
		AllowedChannels: []string{
			mesh.SyntheticChannelFabricControl,
			mesh.SyntheticChannelRouteControl,
		},
		Transport: mesh.NewHTTPPeerTransport(peers),
	})
}

func smokeRoute(routeID string, hops []string) mesh.SyntheticRoute {
	return mesh.SyntheticRoute{
		RouteID:              routeID,
		ClusterID:            "cluster-1",
		SourceNodeID:         hops[0],
		DestinationNodeID:    hops[len(hops)-1],
		Hops:                 hops,
		AllowedChannels:      []string{mesh.SyntheticChannelFabricControl, mesh.SyntheticChannelRouteControl},
		MaxTTL:               8,
		MaxHops:              8,
		ExpiresAt:            time.Now().UTC().Add(time.Hour),
		RouteVersion:         "route-v1",
		PolicyVersion:        "policy-v1",
		PeerDirectoryVersion: "peers-v1",
	}
}

func decodeProbePath(envelope mesh.SyntheticEnvelope) []string {
	var payload mesh.SyntheticProbeAckPayload
	_ = json.Unmarshal(envelope.Payload, &payload)
	return payload.Path
}