// cmd/mcp-weather/main.go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/modelcontextprotocol/go-sdk/mcp"
)

type GetWeatherInput struct {
	City string `json:"city" jsonschema:"description=City name in English"`
}

type GetWeatherOutput struct {
	City        string  `json:"city"`
	TemperatureC float64 `json:"temperature_c"`
	Condition   string  `json:"condition"`
}

func getWeather(ctx context.Context, req *mcp.CallToolRequest, in GetWeatherInput) (
	*mcp.CallToolResult, GetWeatherOutput, error,
) {
	// 実運用では外部APIを叩く。ここではダミー応答。
	out := GetWeatherOutput{
		City:        in.City,
		TemperatureC: 22.5,
		Condition:   "Sunny",
	}
	text := fmt.Sprintf("%s is %.1f°C and %s.", out.City, out.TemperatureC, out.Condition)
	return &mcp.CallToolResult{
		Content: []mcp.Content{&mcp.TextContent{Text: text}},
	}, out, nil
}

func main() {
	srv := mcp.NewServer(
		&mcp.Implementation{Name: "weather", Version: "0.1.0"},
		nil,
	)

	mcp.AddTool(srv, &mcp.Tool{
		Name:        "get_weather",
		Description: "Get current weather for a city.",
	}, getWeather)

	// stdio トランスポート（Claude Desktop / Codex CLI などが想定）
	if err := srv.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
		log.Fatal(err)
	}
}

// cmd/mcp-call/main.go
package main

import (
	"context"
	"fmt"
	"log"
	"os/exec"

	"github.com/modelcontextprotocol/go-sdk/mcp"
)

func main() {
	ctx := context.Background()
	client := mcp.NewClient(&mcp.Implementation{Name: "demo", Version: "0.1.0"}, nil)

	// 子プロセスとしてサーバを起動し、stdio で接続する
	cmd := exec.Command("./mcp-weather")
	session, err := client.Connect(ctx, &mcp.CommandTransport{Command: cmd}, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close()

	res, err := session.CallTool(ctx, &mcp.CallToolParams{
		Name:      "get_weather",
		Arguments: map[string]any{"city": "Tokyo"},
	})
	if err != nil {
		log.Fatal(err)
	}
	for _, c := range res.Content {
		if t, ok := c.(*mcp.TextContent); ok {
			fmt.Println(t.Text) // → "Tokyo is 22.5°C and Sunny."
		}
	}
}

// cmd/a2a-agent/main.go
package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type Skill struct {
	ID          string   `json:"id"`
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Tags        []string `json:"tags"`
	InputModes  []string `json:"inputModes"`
	OutputModes []string `json:"outputModes"`
}

type AgentCard struct {
	ProtocolVersion string   `json:"protocolVersion"`
	Name            string   `json:"name"`
	Description     string   `json:"description"`
	URL             string   `json:"url"`
	Version         string   `json:"version"`
	Capabilities    map[string]any `json:"capabilities"`
	DefaultInputModes  []string `json:"defaultInputModes"`
	DefaultOutputModes []string `json:"defaultOutputModes"`
	Skills          []Skill  `json:"skills"`
}

var card = AgentCard{
	ProtocolVersion: "0.3.0",
	Name:            "translation-agent",
	Description:     "Translates plain text between Japanese and English.",
	URL:             "https://example.com/a2a",
	Version:         "1.0.0",
	Capabilities: map[string]any{
		"streaming":         true,
		"pushNotifications": false,
	},
	DefaultInputModes:  []string{"text/plain"},
	DefaultOutputModes: []string{"text/plain"},
	Skills: []Skill{{
		ID:          "translate",
		Name:        "Translate JA<->EN",
		Description: "Translate text between Japanese and English.",
		Tags:        []string{"translation", "nlp"},
		InputModes:  []string{"text/plain"},
		OutputModes: []string{"text/plain"},
	}},
}

func main() {
	http.HandleFunc("/.well-known/agent-card.json", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(card)
	})
	http.HandleFunc("POST /a2a", handleTaskRPC) // 次節で実装
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleTaskRPC(w http.ResponseWriter, r *http.Request) {
	var req struct {
		JSONRPC string          `json:"jsonrpc"`
		ID      json.RawMessage `json:"id"`
		Method  string          `json:"method"`
		Params  struct {
			Message struct {
				Role  string `json:"role"`
				Parts []struct {
					Kind string `json:"kind"`
					Text string `json:"text"`
				} `json:"parts"`
			} `json:"message"`
		} `json:"params"`
	}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "bad request", http.StatusBadRequest)
		return
	}

	if req.Method != "message/send" {
		writeRPCError(w, req.ID, -32601, "method not found")
		return
	}

	// ここで実翻訳。サンプルはエコー。
	input := req.Params.Message.Parts[0].Text
	output := "[ja->en] " + input

	resp := map[string]any{
		"jsonrpc": "2.0",
		"id":      req.ID,
		"result": map[string]any{
			"kind": "message",
			"role": "agent",
			"parts": []map[string]any{
				{"kind": "text", "text": output},
			},
		},
	}
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(resp)
}

func writeRPCError(w http.ResponseWriter, id json.RawMessage, code int, msg string) {
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(map[string]any{
		"jsonrpc": "2.0",
		"id":      id,
		"error":   map[string]any{"code": code, "message": msg},
	})
}

// cmd/agui/main.go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"time"
)

type event struct {
	Type string
	Data map[string]any
}

func writeSSE(w http.ResponseWriter, ev event) error {
	b, err := json.Marshal(ev.Data)
	if err != nil {
		return err
	}
	if _, err := fmt.Fprintf(w, "event: %s\ndata: %s\n\n", ev.Type, b); err != nil {
		return err
	}
	if f, ok := w.(http.Flusher); ok {
		f.Flush()
	}
	return nil
}

func runHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/event-stream")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")

	threadID, runID := "t_1", "r_1"
	msgID := "m_1"

	events := []event{
		{"RUN_STARTED", map[string]any{"threadId": threadID, "runId": runID}},
		{"TEXT_MESSAGE_START", map[string]any{"messageId": msgID, "role": "assistant"}},
		{"TEXT_MESSAGE_CONTENT", map[string]any{"messageId": msgID, "delta": "今週の売上を集計します"}},
		{"TOOL_CALL_START", map[string]any{"toolCallId": "tc_1", "toolCallName": "query_sales"}},
		{"TOOL_CALL_END", map[string]any{"toolCallId": "tc_1"}},
		{"STATE_DELTA", map[string]any{
			"delta": []map[string]any{
				{"op": "add", "path": "/sales/mon", "value": 1_200_000},
			},
		}},
		{"TEXT_MESSAGE_END", map[string]any{"messageId": msgID}},
		{"RUN_FINISHED", map[string]any{"threadId": threadID, "runId": runID}},
	}

	for _, ev := range events {
		if err := writeSSE(w, ev); err != nil {
			log.Printf("write: %v", err)
			return
		}
		select {
		case <-time.After(150 * time.Millisecond):
		case <-r.Context().Done():
			return
		}
	}
}

func main() {
	http.HandleFunc("POST /agui/run", runHandler)
	log.Fatal(http.ListenAndServe(":8081", nil))
}

// AGUIClient.swift
import Foundation

enum AGUIEvent {
    case runStarted(threadId: String, runId: String)
    case textContent(messageId: String, delta: String)
    case toolCallStart(toolCallId: String, name: String)
    case stateDelta(patches: [[String: Any]])
    case runFinished(threadId: String, runId: String)
    case other(name: String, payload: [String: Any])
}

actor AGUIClient {
    let endpoint: URL

    init(endpoint: URL) {
        self.endpoint = endpoint
    }

    func run() -> AsyncThrowingStream<AGUIEvent, Error> {
        AsyncThrowingStream { continuation in
            Task {
                do {
                    var req = URLRequest(url: endpoint)
                    req.httpMethod = "POST"
                    req.setValue("text/event-stream", forHTTPHeaderField: "Accept")

                    let (bytes, _) = try await URLSession.shared.bytes(for: req)
                    var eventName = ""
                    var dataBuffer = ""

                    for try await line in bytes.lines {
                        if line.isEmpty {
                            if let event = Self.parse(name: eventName, data: dataBuffer) {
                                continuation.yield(event)
                            }
                            eventName = ""
                            dataBuffer = ""
                            continue
                        }
                        if line.hasPrefix("event:") {
                            eventName = line.dropFirst("event:".count)
                                .trimmingCharacters(in: .whitespaces)
                        } else if line.hasPrefix("data:") {
                            dataBuffer += line.dropFirst("data:".count)
                                .trimmingCharacters(in: .whitespaces)
                        }
                    }
                    continuation.finish()
                } catch {
                    continuation.finish(throwing: error)
                }
            }
        }
    }

    private static func parse(name: String, data: String) -> AGUIEvent? {
        guard !name.isEmpty, !data.isEmpty,
              let raw = data.data(using: .utf8),
              let json = try? JSONSerialization.jsonObject(with: raw) as? [String: Any]
        else { return nil }

        switch name {
        case "RUN_STARTED":
            return .runStarted(
                threadId: json["threadId"] as? String ?? "",
                runId: json["runId"] as? String ?? ""
            )
        case "TEXT_MESSAGE_CONTENT":
            return .textContent(
                messageId: json["messageId"] as? String ?? "",
                delta: json["delta"] as? String ?? ""
            )
        case "TOOL_CALL_START":
            return .toolCallStart(
                toolCallId: json["toolCallId"] as? String ?? "",
                name: json["toolCallName"] as? String ?? ""
            )
        case "STATE_DELTA":
            return .stateDelta(patches: json["delta"] as? [[String: Any]] ?? [])
        case "RUN_FINISHED":
            return .runFinished(
                threadId: json["threadId"] as? String ?? "",
                runId: json["runId"] as? String ?? ""
            )
        default:
            return .other(name: name, payload: json)
        }
    }
}

// internal/didweb/resolver.go
package didweb

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"
)

type DIDDocument struct {
	Context            []string `json:"@context"`
	ID                 string   `json:"id"`
	VerificationMethod []struct {
		ID                 string         `json:"id"`
		Type               string         `json:"type"`
		Controller         string         `json:"controller"`
		PublicKeyJwk       map[string]any `json:"publicKeyJwk,omitempty"`
	} `json:"verificationMethod"`
	Service []struct {
		ID              string `json:"id"`
		Type            string `json:"type"`
		ServiceEndpoint string `json:"serviceEndpoint"`
	} `json:"service,omitempty"`
}

func Resolve(ctx context.Context, did string) (*DIDDocument, error) {
	if !strings.HasPrefix(did, "did:web:") {
		return nil, errors.New("not a did:web identifier")
	}
	parts := strings.Split(strings.TrimPrefix(did, "did:web:"), ":")
	if len(parts) == 0 {
		return nil, errors.New("empty did:web identifier")
	}

	// did:web:example.com           → https://example.com/.well-known/did.json
	// did:web:example.com:agents:a  → https://example.com/agents/a/did.json
	host, err := url.PathUnescape(parts[0])
	if err != nil {
		return nil, fmt.Errorf("decode host: %w", err)
	}
	u := &url.URL{Scheme: "https", Host: host}
	if len(parts) == 1 {
		u.Path = "/.well-known/did.json"
	} else {
		segs := make([]string, 0, len(parts)-1)
		for _, p := range parts[1:] {
			seg, err := url.PathUnescape(p)
			if err != nil {
				return nil, fmt.Errorf("decode path: %w", err)
			}
			segs = append(segs, seg)
		}
		u.Path = "/" + strings.Join(segs, "/") + "/did.json"
	}

	cctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()
	req, _ := http.NewRequestWithContext(cctx, http.MethodGet, u.String(), nil)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("status %d for %s", resp.StatusCode, u.String())
	}

	var doc DIDDocument
	if err := json.NewDecoder(resp.Body).Decode(&doc); err != nil {
		return nil, err
	}
	if doc.ID != did {
		return nil, fmt.Errorf("did mismatch: doc=%q req=%q", doc.ID, did)
	}
	return &doc, nil
}

// internal/x402/middleware.go
package x402

import (
	"encoding/base64"
	"encoding/json"
	"net/http"
)

type Requirement struct {
	Scheme     string `json:"scheme"`      // "exact"
	Network    string `json:"network"`     // "base", "base-sepolia"
	MaxAmount  string `json:"maxAmountRequired"` // atomic units in string
	Asset      string `json:"asset"`       // token contract address
	PayTo      string `json:"payTo"`       // receiver address
	Resource   string `json:"resource"`    // URL of the protected resource
	MimeType   string `json:"mimeType"`
	MaxTimeout int    `json:"maxTimeoutSeconds"`
}

type PaymentRequiredBody struct {
	X402Version int           `json:"x402Version"`
	Accepts     []Requirement `json:"accepts"`
	Error       string        `json:"error,omitempty"`
}

type Facilitator interface {
	Verify(payload []byte, req Requirement) error
	Settle(payload []byte, req Requirement) error
}

func Middleware(req Requirement, f Facilitator, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		header := r.Header.Get("X-PAYMENT")
		if header == "" {
			writeRequired(w, req, "missing X-PAYMENT")
			return
		}
		payload, err := base64.StdEncoding.DecodeString(header)
		if err != nil {
			writeRequired(w, req, "X-PAYMENT must be base64")
			return
		}
		if err := f.Verify(payload, req); err != nil {
			writeRequired(w, req, "verify failed: "+err.Error())
			return
		}
		// 検証OK → 本来のレスポンスを返してから決済（または先に決済→応答）
		next.ServeHTTP(w, r)
		_ = f.Settle(payload, req)
	})
}

func writeRequired(w http.ResponseWriter, req Requirement, msg string) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusPaymentRequired)
	_ = json.NewEncoder(w).Encode(PaymentRequiredBody{
		X402Version: 1,
		Accepts:     []Requirement{req},
		Error:       msg,
	})
}