import (
	"errors"
	"fmt"
	"strings"

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

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

type Order struct {
	ID       string
	Total    int
	Customer string
}

// BadOrderHandler は SRP 違反: 読み取り・検証・通知を全部 1 つの型でやる。
type BadOrderHandler struct{}

func (h *BadOrderHandler) Handle(raw Order) error {
	// 責任 1: 注文を「検証」する
	if raw.ID == "" {
		return errors.New("order ID is empty")
	}
	if raw.Total <= 0 {
		return errors.New("order total must be positive")
	}
	// 責任 2: 注文を「記録」する（簡易実装: ログ出力）
	fmt.Printf("注文 %s を記録しました（合計 %d 円, %s 様）\n", raw.ID, raw.Total, raw.Customer)
	// 責任 3: 注文を「通知」する
	fmt.Printf("[Email] %s 様、ご注文が確定しました\n", raw.Customer)
	return nil
}

%%
h := &BadOrderHandler{}
_ = h.Handle(Order{ID: "ORD-1", Total: 3000, Customer: "佐藤"})
fmt.Println("→ 検証・記録・通知が 1 つの Handle に混ざっている")

注文 ORD-1 を記録しました（合計 3000 円, 佐藤 様）
[Email] 佐藤 様、ご注文が確定しました
→ 検証・記録・通知が 1 つの Handle に混ざっている

// 検証の責任
type OrderValidator struct{}

func (v *OrderValidator) Validate(o Order) error {
	if o.ID == "" {
		return errors.New("order ID is empty")
	}
	if o.Total <= 0 {
		return errors.New("order total must be positive")
	}
	return nil
}

// 記録の責任
type OrderRecorder struct{}

func (r *OrderRecorder) Record(o Order) {
	fmt.Printf("注文 %s を記録しました（合計 %d 円, %s 様）\n", o.ID, o.Total, o.Customer)
}

// 通知の責任
type OrderNotifier struct{}

func (n *OrderNotifier) Notify(o Order) {
	fmt.Printf("[Email] %s 様、ご注文が確定しました\n", o.Customer)
}

// GoodOrderHandler は責任の「組み立て」だけをする
type GoodOrderHandler struct {
	validator OrderValidator
	recorder  OrderRecorder
	notifier  OrderNotifier
}

func (h *GoodOrderHandler) Handle(o Order) error {
	if err := h.validator.Validate(o); err != nil {
		return err
	}
	h.recorder.Record(o)
	h.notifier.Notify(o)
	return nil
}

%%
g := &GoodOrderHandler{}
_ = g.Handle(Order{ID: "ORD-1", Total: 3000, Customer: "佐藤"})
fmt.Println("→ 同じ挙動。ただし責任ごとに独立している")

注文 ORD-1 を記録しました（合計 3000 円, 佐藤 様）
[Email] 佐藤 様、ご注文が確定しました
→ 同じ挙動。ただし責任ごとに独立している

type Notifier interface {
	Notify(message string) error
}

// AlertService は Notifier（抽象）にだけ依存する。
// 具体的な通知方法はコンストラクタで注入される（依存性注入 DI）。
type AlertService struct {
	notifier Notifier
}

func NewAlertService(n Notifier) *AlertService {
	return &AlertService{notifier: n}
}

func (s *AlertService) Send(alert string) error {
	return s.notifier.Notify("アラート: " + alert)
}

type LogN struct{}

func (n LogN) Notify(message string) error {
	fmt.Printf("[Log] %s\n", message)
	return nil
}

type EmailN struct{ addr string }

func (e EmailN) Notify(msg string) error {
	fmt.Printf("[Email → %s] %s\n", e.addr, msg)
	return nil
}

%%
logN := LogN{}
svcLog := NewAlertService(logN)
_ = svcLog.Send("サーバー負荷が高い")

// 通知方法を Email に差し替えても AlertService は無変更
svcEmail := NewAlertService(EmailN{addr: "taro@example.com"})
_ = svcEmail.Send("サーバー負荷が高い")
fmt.Println("→ 同じ Send が、注入する Notifier に応じて異なる通知をする")

[Log] アラート: サーバー負荷が高い
[Email → taro@example.com] アラート: サーバー負荷が高い
→ 同じ Send が、注入する Notifier に応じて異なる通知をする

type OrderService struct {
	notifier Notifier
}

func NewOrderService(n Notifier) *OrderService {
	return &OrderService{notifier: n}
}

func (s *OrderService) Complete(orderID string) error

// YOUR CODE HERE
// OrderService の型・NewOrderService・Complete を実装してください。
// （未実装のままチェックセルを実行すると「未回答」と表示されます）
type OrderService struct {
	notifier Notifier
}

func NewOrderService(n Notifier) *OrderService {
	return &OrderService{notifier: n}
}

func (s *OrderService) Complete(orderID string) error {
	return ErrUnanswered
}

import "reflect"
import "fmt"

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))
}

// チェック用の記録型 Notifier
type recorderNotifier struct {
	messages []string
}

func (r *recorderNotifier) Notify(message string) error {
	r.messages = append(r.messages, message)
	return nil
}

%%
rec := &recorderNotifier{}
svc := NewOrderService(rec)

err := svc.Complete("ORD-1")
if errors.Is(err, ErrUnanswered) {
	fmt.Println("⚠️ 未回答: 練習問題を解いてから、このセルを再度実行してください")
} else {
	mustEqual(err, nil, "Complete はエラーなし")
	mustEqual(rec.messages, []string{"注文 ORD-1 が完了しました"}, "注入された notifier が使われた")
	mustEqual(len(rec.messages), 1, "1 回だけ通知された")
	fmt.Println("🎉 すべてのチェックが通りました")
}

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

01.6 SOLID と定番パターン — 変更に強い設計（SRP / OCP / DIP）¶

1. SRP: 1 つの型に 1 つの責任¶

2. SRP 準拠に分解する（挙動は同じまま）¶

3. OCP / DIP: 抽象に依存して、拡張に対して開く¶

4. 直感・類推: レストランの厨房¶

練習問題 1.6: OrderService を実装しよう¶

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

まとめ¶