import (
	"errors"
	"fmt"
	"net"
	"strings"
	"sync"
	"time"

	"github.com/janpfeifer/gonb/gonbui"
)

// ErrUnanswered は、練習問題が未回答のときにプレースホルダ関数が返す特別なエラー。
var ErrUnanswered = errors.New("未回答: この関数はまだ実装されていません")

// connEvent は、クライアント/サーバー間で起きた1つの出来事（Listen/Accept/Read/Write/Close）を表す。
type connEvent struct {
	time   string
	actor  string
	action string
	data   string
}

var demoEvents []connEvent

func renderConnEvents(events []connEvent) string {
	var b strings.Builder
	b.WriteString(`<table border="1" cellpadding="4" style="border-collapse:collapse">`)
	b.WriteString(`<tr><th>時刻</th><th>主体</th><th>動作</th><th>データ</th></tr>`)
	for _, e := range events {
		b.WriteString(fmt.Sprintf(`<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>`,
			e.time, e.actor, e.action, e.data))
	}
	b.WriteString(`</table>`)
	return b.String()
}

// runEchoDemo は、ポート0（OSが空きポートを自動選択）で1回限りのTCPエコーサーバーを起動し、
// クライアントから 接続→送信→応答受信→切断 までを実演する。
// サーバー側は goroutine で動かし、処理が終わったら done チャネルを close して終了を通知する。
// 呼び出し元は select でタイムアウト付きに終了を待ってからセルを終える
// （ぶら下がり goroutine を残さない）。
func runEchoDemo() []connEvent {
	var events []connEvent
	record := func(actor, action, data string) {
		events = append(events, connEvent{
			time:   time.Now().Format("15:04:05.000"),
			actor:  actor,
			action: action,
			data:   data,
		})
	}

	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		panic(err)
	}
	record("server", "Listen", ln.Addr().String())

	done := make(chan struct{})
	go func() {
		defer close(done)
		conn, err := ln.Accept()
		if err != nil {
			return
		}
		record("server", "Accept", conn.RemoteAddr().String())

		conn.SetDeadline(time.Now().Add(5 * time.Second))
		buf := make([]byte, 1024)
		n, err := conn.Read(buf)
		if err != nil {
			conn.Close()
			return
		}
		received := string(buf[:n])
		record("server", "Read", received)

		conn.Write(buf[:n])
		record("server", "Write (echo)", received)

		conn.Close()
		record("server", "Close", "")
	}()

	conn, err := net.DialTimeout("tcp", ln.Addr().String(), 5*time.Second)
	if err != nil {
		panic(err)
	}
	record("client", "Dial", ln.Addr().String())

	msg := "hello, server"
	if _, err := conn.Write([]byte(msg)); err != nil {
		panic(err)
	}
	record("client", "Write", msg)

	conn.SetDeadline(time.Now().Add(5 * time.Second))
	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil {
		panic(err)
	}
	echoed := string(buf[:n])
	record("client", "Read (echo)", echoed)

	conn.Close()
	record("client", "Close", "")

	// サーバー側 goroutine の終了を待ってからセルを終える（有限の待機上限つき）。
	select {
	case <-done:
	case <-time.After(5 * time.Second):
		fmt.Println("⚠️ サーバーgoroutineがタイムアウトした")
	}

	ln.Close()
	return events
}

%%
demoEvents = runEchoDemo()
for _, e := range demoEvents {
	fmt.Printf("[%s] %-6s %-14s %q\n", e.time, e.actor, e.action, e.data)
}
gonbui.DisplayHTML(renderConnEvents(demoEvents))
gonbui.Sync()

[17:42:49.764] server Listen         "127.0.0.1:59853"
[17:42:49.764] client Dial           "127.0.0.1:59853"
[17:42:49.764] client Write          "hello, server"
[17:42:49.764] server Accept         "127.0.0.1:59854"
[17:42:49.764] server Read           "hello, server"
[17:42:49.764] server Write (echo)   "hello, server"
[17:42:49.764] server Close          ""
[17:42:49.764] client Read (echo)    "hello, server"
[17:42:49.764] client Close          ""

func sendAndReceive(addr string, message string) (string, error)

// YOUR CODE HERE
// func sendAndReceive(addr string, message string) (string, error) を実装してください。
// （未実装のままチェックセルを実行すると「未回答」と表示されます）
func sendAndReceive(addr string, message string) (string, error) {
	return "", ErrUnanswered
}

// startPersistentEchoServer は、stop() が呼ばれるまで複数の接続を受け続けるTCPエコーサーバーを起動する。
func startPersistentEchoServer() (addr string, stop func()) {
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		panic(err)
	}

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		for {
			conn, err := ln.Accept()
			if err != nil {
				return // リスナーが閉じられた
			}
			wg.Add(1)
			go func() {
				defer wg.Done()
				defer conn.Close()
				conn.SetDeadline(time.Now().Add(5 * time.Second))
				buf := make([]byte, 1024)
				n, err := conn.Read(buf)
				if err != nil {
					return
				}
				conn.Write(buf[:n])
			}()
		}
	}()

	stop = func() {
		ln.Close()
		waitDone := make(chan struct{})
		go func() {
			wg.Wait()
			close(waitDone)
		}()
		select {
		case <-waitDone:
		case <-time.After(5 * time.Second):
			fmt.Println("⚠️ サーバーgoroutineがタイムアウトした")
		}
	}
	return ln.Addr().String(), stop
}

import "reflect"

func mustEqual(got, want any, name string) {
	if reflect.DeepEqual(got, want) {
		fmt.Printf("✅ Passed: %s\n", name)
		return
	}
	panic(fmt.Sprintf("❌ %s\n  got  = %v (%T)\n  want = %v (%T)", name, got, got, want, want))
}

%%
addr, stop := startPersistentEchoServer()
defer stop()

resp1, err1 := sendAndReceive(addr, "ping")
if errors.Is(err1, ErrUnanswered) {
	fmt.Println("⚠️ 未回答: 練習問題を解いてから、このセルを再度実行してください")
} else {
	mustEqual(err1, nil, `sendAndReceive("ping") はエラーなし`)
	mustEqual(resp1, "ping", "レスポンスは送信した文字列と同じ")

	resp2, err2 := sendAndReceive(addr, "こんにちは")
	mustEqual(err2, nil, "日本語文字列もエラーなし")
	mustEqual(resp2, "こんにちは", "日本語文字列も echo される")

	// 一度開いてすぐ閉じたアドレス = 「今は誰も listen していない」ことが保証されたアドレス。
	deadLn, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		panic(err)
	}
	deadAddr := deadLn.Addr().String()
	deadLn.Close()

	_, err3 := sendAndReceive(deadAddr, "x")
	mustEqual(err3 != nil, true, "接続できないアドレスはエラーを返す")

	fmt.Println("🎉 すべてのチェックが通りました")
}

⚠️ 未回答: 練習問題を解いてから、このセルを再度実行してください

03.1 クライアント・サーバーモデルと TCP — ネットワーク通信の基本単位¶

非自明ポイント¶

実際に動かしてみる: 1回限りのTCPエコーサーバー¶

可視化: 通信の時系列¶

TCP と UDP¶

直感・類推: 電話をかける¶

練習問題 3.1: sendAndReceive を実装しよう¶

チェックのためのヘルパー¶

まとめ¶

時刻	主体	動作	データ
17:42:49.764	server	Listen	127.0.0.1:59853
17:42:49.764	client	Dial	127.0.0.1:59853
17:42:49.764	client	Write	hello, server
17:42:49.764	server	Accept	127.0.0.1:59854
17:42:49.764	server	Read	hello, server
17:42:49.764	server	Write (echo)	hello, server
17:42:49.764	server	Close
17:42:49.764	client	Read (echo)	hello, server
17:42:49.764	client	Close