func (r *Impl) Execute() {
    // トランザクションを使用していないため、途中でエラーが発生しても処理が中断されるだけで、
    // それまでに実行された処理（Save）はロールバックされずにデータベースに残ってしまう
    if err := db.Save().Error; err != nil {
        return err // エラー時にロールバックされない
    }

    // 2つ目の処理（Create）がエラーになった場合でも、最初の Save() は既に実行されており、
    // 途中でデータの不整合が発生する可能性がある
    if err := db.Create().Error; err != nil {
        return err // ここでエラーになっても Save() の結果は取り消されない
    }

    return nil // どちらも成功した場合、問題はないが、一貫性が保証されない
}

func (r *Impl) Execute() {
    err := r.db.Transaction(func(tx *gorm.DB) error {
        // トランザクションの開始
        // このブロック内の処理はすべて成功すればコミットされ、エラーが発生すればロールバックされる

        if err := tx.Save().Error; err != nil {
            return err // エラーが発生した場合、自動的にロールバックされる
        }

        if err := tx.Create().Error; err != nil {
            return err // ここでエラーが発生した場合も、すべての変更がロールバックされる
        }

        return nil // すべて成功した場合、コミットされる
    })

    if err != nil {
        // トランザクション内でエラーが発生した場合、ロールバックされ、エラーメッセージを出力
        fmt.Println("Transaction failed:", err)
    }
}

func (r *Impl) Execute(userID uint) error {
    // ユーザーの訪問回数を更新
    if err := r.db.Model(&User{}).Where("id = ?", userID).
        Update("visit_count", gorm.Expr("visit_count + 1")).Error; err != nil {
        return err // どの段階でエラーが発生したのかが不明
    }
    return nil
}

func (r *Impl) Execute(userID uint, newVisitCount uint) error {
    // ユーザーの訪問回数を指定した値に更新
    if err := r.db.Model(&User{}).Where("id = ?", userID).
        Update("visit_count", newVisitCount).Error; err != nil {
        return fmt.Errorf("failed to update visit count: %w", err)
    }
    return nil
}

func (r *Impl) Execute(userID uint, expectedVisit uint) error {
    return r.db.Transaction(func(tx *gorm.DB) error {
        var currentVisit uint

        // 行ロックをかけて現在の訪問回数を取得
        if err := tx.Raw("SELECT visit_count FROM users WHERE id = ? FOR UPDATE", userID).
            Scan(&currentVisit).Error; err != nil {
            return fmt.Errorf("failed to fetch visit count: %w", err)
        }

        // 取得した訪問回数が期待値と異なる場合は更新しない
        if currentVisit != expectedVisit {
            return fmt.Errorf("visit count mismatch: expected %d, got %d", expectedVisit, currentVisit)
        }

        // 訪問回数を更新
        if err := tx.Model(&User{}).Where("id = ?", userID).
            Update("visit_count", gorm.Expr("visit_count + 1")).Error; err != nil {
            return fmt.Errorf("failed to update visit count: %w", err)
        }

        return nil
    })
}

func (r *Impl) Execute(userID uint, newVisitCount uint) error {
    // ユーザーの訪問回数を更新（アクティブレコードスタイル）

    // ❶ メモリ上のオブジェクトとしてUserを取得
    user := &User{}
    if err := r.db.First(user, userID).Error; err != nil {
        return fmt.Errorf("failed to find user: %w", err) // ユーザーが見つからなかった場合のエラーハンドリング
    }

    // ❷ メモリ上のオブジェクトのフィールドを更新
    user.VisitCount = newVisitCount

    // ❸ `Save` を実行し、変更内容をデータベースに反映
    if err := r.db.Save(user).Error; err != nil {
        return fmt.Errorf("failed to update visit count: %w", err) // データ更新時のエラーハンドリング
    }

    return nil // 正常終了
}

type Color struct {
	r uint8
	g uint8
	b uint8
}

// 同一性判定
func (c Color) Equal(other Color) bool {
	return c.r == other.r && c.g == other.g && c.b == other.b
}

// 値オブジェクトの生成
func NewColor(r, g, b int) (*Color, error) {
	if r < 0 || r > 255 {
		return nil, fmt.Errorf("invalid red value: %d", r)
	}
	if g < 0 || g > 255 {
		return nil, fmt.Errorf("invalid green value: %d", g)
	}
	if b < 0 || b > 255 {
		return nil, fmt.Errorf("invalid blue value: %d", b)
	}
	return &Color{r: uint8(r), g: uint8(g), b: uint8(b)}, nil
}

// Shoes はエンティティとして定義され、ID によって同一性が判定される
type Shoes struct {
	id    ShoesID
	color Color
}

// NewShoes はエンティティ Shoes の生成を行うファクトリ関数
func NewShoes(id ShoesID, color Color) *Shoes {
	return &Shoes{
		id:    id,
		color: color,
	}
}

// Equal は、エンティティとしての同一性を ShoesID で判断
func (s *Shoes) Equal(other *Shoes) bool {
	if other == nil {
		return false
	}
	return s.id == other.id
}

// ChangeColor は、Shoes エンティティの状態を変更
// 値オブジェクトである Color を新たに設定することで色を変更
func (s *Shoes) ChangeColor(newColor Color) {
	s.color = newColor
}

// UserId はユーザー識別子を表す型とする。
type UserId string

// Message はチケット内のメッセージを表す構造体とする。
type Message struct {
	From UserId
	Body string
}

// Ticket はチケット集約（Aggregate）を表し、内部でメッセージの管理を行う。
type Ticket struct {
	messages []Message
}

// AddMessage は Ticket の内部状態を変更し、新しい Message を追加する。
// 集約外部からの状態変更は、この公開メソッドを経由してのみ行う。
func (t *Ticket) AddMessage(from UserId, body string) {
	message := Message{From: from, Body: body}
	t.messages = append(t.messages, message)
}

func demoPattern1() {
	ticket := Ticket{}
	ticket.AddMessage("user123", "This is a message body.")
	fmt.Println("パターン１:", ticket.messages)
}

// Ticket2 は別のチケット集約を表し、内部でメッセージの管理を行う。
type Ticket2 struct {
	messages []Message
}

// AddMessageCmd は、Ticket2 に対するメッセージ追加操作を表現するコマンドとする。
type AddMessageCmd struct {
	From UserId
	Body string
}

// Execute は AddMessageCmd コマンドを実行し、Ticket2 の状態を変更する。
// この方法では、操作の意図（「メッセージ追加」）を明示する。
func (t *Ticket2) Execute(cmd AddMessageCmd) {
	message := Message{
		From: cmd.From,
		Body: cmd.Body,
	}
	t.messages = append(t.messages, message)
}

func demoPattern2() {
	ticket := Ticket2{}
	cmd := AddMessageCmd{From: "user456", Body: "This is another message body."}
	ticket.Execute(cmd)
	fmt.Println("パターン２:", ticket.messages)
}

// Escalate は、指定されたチケットをエスカレーションするアプリケーション層の関数とする。
// この関数は、リポジトリからチケットを読み込み、EscalateCmd コマンドを作成して
// 集約内の業務ロジックを実行し、その後チケットを保存する。
func Escalate(repo TicketRepository, id TicketId, reason EscalationReason) ExecutionResult {
	// チケットを読み込む
	ticket, err := repo.Load(id)
	if err != nil {
		return ExecutionResult{Success: false, Error: err}
	}

	// コマンドオブジェクトを作成する
	cmd := EscalateCmd{Reason: reason}

	// チケット集約内でコマンドを実行する
	ticket.Execute(cmd)

	// チケットを保存する
	if err := repo.Save(ticket); err != nil {
		return ExecutionResult{Success: false, Error: err}
	}

	return ExecutionResult{Success: true}
}

// Ticket は集約のルートとして機能する
type Ticket struct {
	messages                []Message
	IsEscalated             bool
	RemainingTimePercentage float64
	AssignedAgent           UserId
}

// Execute は自動アクションの評価を行い、外部からの唯一のアクセス経路となる
func (t *Ticket) Execute(cmd EvaluateAutomaticActions) {
	if t.IsEscalated && t.RemainingTimePercentage < 0.5 &&
		t.GetUnreadMessagesCount(t.AssignedAgent) > 0 {
		t.AssignedAgent = t.AssignNewAgent()
	}
}

// GetUnreadMessagesCount は、指定されたユーザーIDに対する未読メッセージ数を返す
func (t *Ticket) GetUnreadMessagesCount(id UserId) int {
	count := 0
	for _, msg := range t.messages {
		if msg.To == id && !msg.WasRead {
			count++
		}
	}
	return count
}

package main

import "fmt"

// Ticket はチケットを表すエンティティ
type Ticket struct {
	ID       string
	Priority int
}

// Agent はエージェントを表すエンティティ
type Agent struct {
	ID string
}

// TicketService は業務サービスとして、チケットの割当などの業務ロジックを提供する。
// このサービスはステートレスであり、内部に状態を持たない。
type TicketService struct{}

// AssignTicketToAgent は、チケットを指定したエージェントに割り当てる業務ロジックを実装する。
func (s TicketService) AssignTicketToAgent(ticket Ticket, agent Agent) {
	// ここに、チケット割当に関する業務ロジックを実装する
	fmt.Printf("チケット %s をエージェント %s に割り当てた。\n", ticket.ID, agent.ID)
}

func main() {
	// サンプルエンティティの作成
	ticket := Ticket{ID: "T123", Priority: 1}
	agent := Agent{ID: "A456"}

	// 業務サービスのインスタンスはステートレスなため、シンプルに生成する
	service := TicketService{}

	// 業務サービスを利用して、チケットをエージェントに割り当てる
	service.AssignTicketToAgent(ticket, agent)
}